{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evade Signal Classification with FGSM\n",
    "\n",
    "This notebook shows the performance of a digital FGSM attack on an Automatic Modulation Classification neural network model.\n",
    "\n",
    "### Assumptions\n",
    "- The dataset wrangling has already been completed (and is provided here)\n",
    "- The implementation of model training on this dataset has already been completed\n",
    "- The plotting code has already been completed\n",
    "\n",
    "### Components Recreated in Tutorial\n",
    "- FGSM attack constrained by a power ratio\n",
    "\n",
    "### See Also\n",
    "The code in this tutorial is a stripped down version of the code in ``rfml.attack.fgsm`` that simplifies discussion.  Further detail can be provided by directly browsing the source files."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Install the library code and dependencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Install the library code\n",
    "#!pip install git+https://github.com/brysef/rfml.git@1.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "setGPU: Setting GPU to: 1\n"
     ]
    }
   ],
   "source": [
    "# Ensure that the least loaded GPU is used\n",
    "import setGPU\n",
    "\n",
    "# Plotting Includes\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# External Includes\n",
    "import numpy as np\n",
    "\n",
    "import torch\n",
    "from torch.nn.functional import cross_entropy\n",
    "from torch.utils.data import DataLoader, TensorDataset\n",
    "\n",
    "# Internal Includes\n",
    "from rfml.data import Dataset, Encoder\n",
    "from rfml.data import build_dataset\n",
    "\n",
    "from rfml.nbutils import plot_acc_vs_spr, plot_confusion\n",
    "\n",
    "from rfml.nn.eval import compute_accuracy\n",
    "from rfml.nn.eval.confusion import _confusion_matrix\n",
    "from rfml.nn.F import energy\n",
    "from rfml.nn.model import build_model\n",
    "from rfml.nn.train import build_trainer, PrintingTrainingListener"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Configuration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "gpu = True       # Set to True to use a GPU for training\n",
    "fig_dir = None   # Set to a file path if you'd like to save the plots generated\n",
    "data_path = None # Set to a file path if you've downloaded RML2016.10A locally"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train and Evaluate a Model on a Static Dataset\n",
    "\n",
    "See ``module_2`` for a more extensive description of this procedure.\n",
    "Here we just use the library for a quick implementation.\n",
    "In practice, the model training would be separated from the attack, but, is juxtaposed with the attack here for simplicity as it is self-contained for demonstration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0 completed!\n",
      "\t\t-Mean Training Loss: 1.383\n",
      "\t\t-Mean Validation Loss: 1.201\n",
      "Epoch 1 completed!\n",
      "\t\t-Mean Training Loss: 1.189\n",
      "\t\t-Mean Validation Loss: 1.115\n",
      "Epoch 2 completed!\n",
      "\t\t-Mean Training Loss: 1.133\n",
      "\t\t-Mean Validation Loss: 1.062\n",
      "Training has Completed:\n",
      "\n",
      "=======================\n",
      "\tBest Validation Loss: 1.062\n",
      "\tBest Epoch: 2\n",
      "\tTotal Epochs: 2\n",
      "=======================\n",
      "Overall Testing Accuracy: 0.5576\n"
     ]
    }
   ],
   "source": [
    "train, test, val, le = build_dataset(\"RML2016.10a\", path=data_path)\n",
    "# as_numpy returns x,y and x is shape BxCxIQxN\n",
    "input_samples = val.as_numpy(le=le)[0].shape[3]\n",
    "model = build_model(model_name=\"CNN\", input_samples=input_samples, n_classes=len(le))\n",
    "trainer = build_trainer(strategy=\"standard\", max_epochs=3, gpu=gpu)\n",
    "trainer.register_listener(PrintingTrainingListener())\n",
    "trainer(model=model, training=train, validation=val, le=le)\n",
    "acc = compute_accuracy(model=model, data=test, le=le)\n",
    "\n",
    "print(\"Overall Testing Accuracy: {:.4f}\".format(acc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strip Down the Testing Data\n",
    "Strip the data down to only the highest SNR (18 dB in RML2016.10a).  This ensures that the classification accuracy would have been close to the highest and gives the best evaluation of the attack because it separates the decreased accuracy from being causes by low SNR vs being caused by the attack."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "mask = test.df[\"SNR\"] >= 18\n",
    "dl = DataLoader(test.as_torch(le=le, mask=mask), shuffle=True, batch_size=512)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evading Signal Classification with Direct Access to the Classifier\n",
    "\n",
    "Here, we're simply going to sweep the **intensity** of the attack, denoted in this tutorial as $E_s/E_p$ or signal-to-perturbation ratio represented in dB.\n",
    "\n",
    "Recall that the equation for FGSM [Goodfellow et. al] is\n",
    "\n",
    "\\begin{equation}\n",
    "    x^* = x + \\text{sign}(\\nabla_X \\mathcal{L}(f(\\theta, X), y_s))\n",
    "\\end{equation}\n",
    "\n",
    "For the purposes of a clean implementation in software, we can split this equation into multiple steps.\n",
    "First, we must compute the *signed gradient*.\n",
    "\n",
    "\\begin{equation}\n",
    "    \\text{\"signed gradient\"} = \\text{sign}(\\nabla_X \\mathcal{L}(f(\\theta, X), y_s))\n",
    "\\end{equation}\n",
    "\n",
    "This is done by utilizing the model and PyTorch to backpropogate the gradient to the input.\n",
    "Once the gradient is known, we can apply a simple sign operation.\n",
    "\n",
    "Then, the signed gradient must be scaled to achieve an allowed intensity.\n",
    "Traditionally, CV literature uses a norm to constrain the perturbation (e.g. $\\left\\lVert {x - x^*} \\right\\rVert_p < \\epsilon$).\n",
    "In the context of wireless communications, it makes more sense to constrain the power ratio of the perturbation to the underlying signal as the absolute values of either the perturbation or signal generally do not matter.\n",
    "Recall that we've assumed $E_s$ is $1$ and therefore can scale the perturbation using the following equation [Flowers et. al, Sadeghi/Larson].\n",
    "\n",
    "\\begin{equation}\n",
    "    p = \\sqrt{\\frac{10^{\\frac{-E_s/E_p}{10}}}{2 \\times \\text{sps}}} \\times \\text{\"signed gradient\"}\n",
    "\\end{equation}\n",
    "\n",
    "Because the RML2016.10A dataset is not properly normalized for all examples, especially AM-SSB, we have to normalize the input data before running the attack to have a known power -- this is the only way to ensure that the attack intensity is correct.\n",
    "\n",
    "To complete the FGSM algorithm we simply need to add the perturbation to the original example.\n",
    "\n",
    "\\begin{equation}\n",
    "    \\text{\"adversarial example\"} = x + p\n",
    "\\end{equation}\n",
    "\n",
    "#### Citations\n",
    "\n",
    "##### Goodfellow et al\n",
    "\n",
    "Goodfellow, I., Shlens, J., and Szegedy, C. (2015).  Explaining and harnessing adversarial examples. In Int. Conf. on Learning Representations.\n",
    "\n",
    "##### Flowers et al\n",
    "\n",
    "Flowers, B., Buehrer,  R.  M.,  and Headley,  W. C. (2019). Evaluating adversarial evasion attacks in the context of wireless communications. IEEE Transactions on Information Forensics and Security, pages 1–1.\n",
    "\n",
    "##### Sadeghi/Larson\n",
    "\n",
    "Sadeghi, M. and Larsson, E. G. (2018). Adversarial attacks on deep-learning based radio signal classification.IEEEWireless Commun. Letters, pages 1–1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Helper methods for the attack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fgsm(x, y, input_size, net, spr, sps):\n",
    "    p = compute_signed_gradient(x=x, y=y, input_size=input_size, net=net)\n",
    "    p = scale_perturbation(sg=p, spr=spr, sps=sps)\n",
    "    \n",
    "    return x + p\n",
    "\n",
    "\n",
    "def compute_signed_gradient(x, y, input_size, net):\n",
    "    # Ensure that the gradient is tracked at the input, add some noise to avoid any\n",
    "    # actual zeros in the signal (dithering), and then ensure its the proper shape\n",
    "    x.requires_grad = True\n",
    "    _x = _dither(x)\n",
    "\n",
    "    # Put the inputs/outputs onto the most probable device that the model is currently\n",
    "    # on -- this could fail if the model gets split amongst multiple devies, but, that\n",
    "    # doesn't happen in this code.\n",
    "    _x = _x.to(net.device)\n",
    "    y = y.to(net.device)\n",
    "\n",
    "    # Perform forward/backward pass to get the gradient at the input\n",
    "    _y = net(_x)\n",
    "    loss = cross_entropy(_y, y)\n",
    "    loss.backward()\n",
    "\n",
    "    # Take the sign of the gradient that can be scaled later\n",
    "    ret = torch.sign(x.grad.data)\n",
    "\n",
    "    return ret\n",
    "\n",
    "\n",
    "def scale_perturbation(sg, spr, sps):\n",
    "    if spr == np.inf:\n",
    "        return sg * 0\n",
    "    multiplier = pow(10, -spr / 10.0)\n",
    "    multiplier = multiplier / (2 * sps)\n",
    "    multiplier = pow(multiplier, 0.5)\n",
    "\n",
    "    return sg * multiplier\n",
    "\n",
    "\n",
    "def _dither(x):\n",
    "    snr = 100\n",
    "    voltage = pow(pow(10.0, -snr / 10.0), 0.5)\n",
    "\n",
    "    noise = x.data.new(x.size()).normal_(0.0, voltage)\n",
    "    return x + noise\n",
    "\n",
    "\n",
    "def _normalize(x):\n",
    "    power = energy(x)\n",
    "    # Make the dimensions match because broadcasting is too magical to\n",
    "    # understand in its entirety... essentially want to ensure that we\n",
    "    # divide each channel of each example by the sqrt of the power of\n",
    "    # that channel/example pair\n",
    "    power = power.view([power.size()[0], power.size()[1], 1, 1])\n",
    "\n",
    "    return x / torch.sqrt(power)\n",
    "\n",
    "\n",
    "def _sanity_check(desired_spr, adv_x, x):\n",
    "    signal_power = energy(x)\n",
    "    perturbation_power = energy(adv_x - x)\n",
    "    _spr = 10*torch.log10(signal_power / perturbation_power)\n",
    "    _spr = _spr.detach().numpy().mean()\n",
    "    if np.abs(_spr - desired_spr) > 0.5:\n",
    "        raise RuntimeError(\"Calculated SPR and desired SPR does not match: \"\n",
    "                           \"Desired SPR={:0.2f}dB, Calculated SPR={:0.2f}dB, \"\n",
    "                           \"Signal Power={:0.2f}dB, Perturbation Power={:0.2f}dB\".format(\n",
    "                               desired_spr,\n",
    "                               _spr,\n",
    "                               10.0*np.log10(signal_power.detach().numpy().mean()),\n",
    "                               10.0*np.log10(perturbation_power.detach().numpy().mean()))\n",
    "                          )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Top Level control loop for the attack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Ensure that the model is in \"evaluation\" mode\n",
    "# -- Therefore batch normalization is not computed and dropout is not performed\n",
    "# -- Note: This is the cause of a lot of bugs\n",
    "model.eval()\n",
    "\n",
    "acc_vs_spr = list()\n",
    "sprs = list()\n",
    "\n",
    "for spr in np.linspace(50.0, 0.0, num=26):\n",
    "    right = 0\n",
    "    total = 0\n",
    "    \n",
    "    for x, y in dl:\n",
    "        # Before crafting an attack on X, ensure that it is normalized to have a\n",
    "        # specified power -- RML2016.10a fluctuates a bit, especially on AM-SSB,\n",
    "        # which will cause the attack intensity to be incorrect.\n",
    "        x = _normalize(x)\n",
    "        adv_x = fgsm(x, y, spr=spr, input_size=input_samples, sps=1, net=model)\n",
    "        \n",
    "        # Ensure that we've accurately represented the attack power\n",
    "        _sanity_check(desired_spr=spr, adv_x=adv_x, x=x)\n",
    "        \n",
    "        predictions = model.predict(adv_x)\n",
    "        right += (predictions == y).sum().item()\n",
    "        total += len(y)\n",
    "\n",
    "    acc = float(right) / total\n",
    "    acc_vs_spr.append(acc)\n",
    "    sprs.append(spr)\n",
    "\n",
    "fig = plot_acc_vs_spr(acc_vs_spr=acc_vs_spr,\n",
    "                      spr=sprs,\n",
    "                      title=\"Performance of a Digital FGSM Attack\"\n",
    "                     )\n",
    "if fig_dir is not None:\n",
    "    file_path = \"{fig_dir}/direct_access_fgsm.pdf\".format(fig_dir=fig_dir)\n",
    "    print(\"Saving Figure -> {file_path}\".format(file_path=file_path))\n",
    "    fig.savefig(file_path, format=\"pdf\", transparent=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Constructing a Confusion Matrix\n",
    "\n",
    "The model breaks down in a way that generally intuitively makes sense to the expert eye with knowledge of the underlying signal formats.  The analog signals are confused for other analog signals, the PSK/QAM signals are confused for other PSK/QAMs with differing modulation orders, etc.  This behavior was examined more closely for targeted adversarial attacks in [Bair et al.] where it was found that the adversarial distance [Papernot et al.], or put more simply, the adversarial perturbation power required to \"transform\" 50% of the input examples from a source to target class, could be used in a spectral clustering algorithm to recover the relationships between the signal formats.\n",
    "\n",
    "##### Bair et al.\n",
    "\n",
    "Bair, S., Delvecchio, M., Flowers, B., Michaels, A. J., andHeadley, W. C. (2019). On the limitations of targeted adversarial evasion attacks against deep learning enabled modulation recognition. In ACM Workshop on Wireless Security and Machine Learning (WiseML 2019).\n",
    "\n",
    "#### Papernot et al.\n",
    "\n",
    "Papernot,  N.,  McDaniel,  P.,  Jha,  S.,  Fredrikson,  M.,Celik,  Z.  B.,  and  Swami,  A.  (2016).   The  limitations  of  deep  learningin  adversarial  settings.   InIEEE  European  Symposium  on  Security  andPrivacy (EuroS&P), pages 372–387. IEEE."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZsAAAFrCAYAAAAHCiThAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzsnXd4FMX7wD8hoSkkQZK7AAk13FAFFCkCEoJAIKFEUFAEURRFQERAEBAVe0EBBaWJoD+/YkMQMPTQmygllBEQCAnkEmoSWtr9/ti95FpCQO4wcT7Ps8/dzrwz75TdeXfK7nhZLBYUCoVCoXAnJW53AhQKhUJR/FHGRqFQKBRuRxkbhUKhULgdZWwUCoVC4XaUsVEoFAqF21HGRqFQKBRux+d2J+C/jBAiDJgBmABvoLyUMv0fxDcAmAesl1KG3YIk/usQQrwOvAbMl1IOcLOuARSiPIUQXwFPAG9IKV93Z5rciU1+90gpG9/m5PznEEJUB44BSCm9bm9qbj3K2OSDEKIVMBa4H7gTSASWAyOllBm3SM0MoC4QA0jgn8Z7AJgKHPmH8eSL7Q0BXASqSCkv6X4TgDd1v0IbAyGE9WWvGlLK49cR34aWxx2FT/VNY1eet7MxEEI0Aj4GmgHlgBNSyuoOMtXR0tseyAZWAC9IKZP+gV7bF/GygGRgDfCSlPJMPmFigbYuvKKllL/oMv7AOKA7UA24CsSj3QvjpJRZQog7gHeAhwAjkAr8BbwnpfxVj+e4Hh6gjZRyk+7eGtiouzuVlYs0bwDa6KeRUsrlNn6v4+IBx0Z3OyllbEHxK5SxcYkQog/wDVpvYw+wE6gOPAe8yj83ClZM+u8QKeXf/zQyKeUOPNMIW/EDHgXmCCG8gUHuVCaEKCmljEFrkNzObSjPgqgKBAF/ktco5iKEKAEsA+oBK4HSwMNACNDyFuj/FjgPRAP90AzPU9cJs0FPr5WjeloDga1ALSANWIr24FIXGAVMAtKBd4EXgIO6TADQAmgE/OpC33PAJv3/4MJmTAhRDWht4/Q42oOl4haijI0D+tPUdDRD8w3whJQyR/erBVzW/98NfAA0BSxoT9yjpJRS9z+O9tTzCtAbzbCsB/pKKc87PDEeFUKcAMJweHJ2HKIRQtyD9vTaCG3O7TgwXUr5uathHyHEA8BbwN162tcBo6WUp3R/azqGod3YlYDFwFOF6MGdR7up5wCRaA3beaCCTXlWAhaiNYJ+wAW0J+6hUsoLDuVwTAgB0E4vi9eAn4AcoCswWH96fw2YDzypx9UBGCOl/MCmd/WblLKLbWJ1g3gO8AUMwBn9vDzgj/YQcREoCVREa1jnodXbAPJ6dHa9MRsVFYUQPwMRaL2h/lLK3a4KTggxGeiJZkBygL3A2PyekPUn+V+FED1wYWyAbmhlvE9K2UnP61GghRAizFW8QojKwFdAK+APYK0r3TofSil3CyEkMA2oU4CslUVSyiku3CehGZqzwD1SynibNNVF6+WAdh2Ads/8qft7odWVI+eBXkKIFwEvoBcO12IB9NXD/Ak0AboLIcpJKdNtejUATwghnkC7HqqT16Nap1+3T6KV4yxAoPVAz6Bdwy9Z7ychRAu9DJoAZYE4INwxUUKIULTemQF4Ukq5oBB5+deiFgg40wq4S///ltXQAEgpj0opM/QGdD3QCc3I/AlEAbFCCMeLeyJaQ3IV6Ay8pLtPtZGZB3xZyPRNQ3sKWwn8D+2GuteVoG4QV+vyMcAJ4DEgRghR0kH8DWALmpHti/b0ej3mA/cIIZqhGZ004GcHmfJoN9SvwGw9vX2B93R/x3KYCiTYuPVEa5i+BuyGg6SUFrQb/DzwuhCiO1rP8ywunrqllNnkPfm2BOqjNVzeaE/M9wBlgN1SyosOwVP19FmZqh+pNm5D0BqtY0BD4FPHNNhQA9gOzEV7AGgO/CCEKF9AmIJoov/ugty8WnsV+c2/fItmqOP1NI8pIP7RQojPbGR+KkSaooUQU2wO633VTf+dY2to9HQflFJm6aen9d9fhRBzhBBPAkYp5XkXuuaj9eae0o9SaIa0MPTVfz8G9gN3oF13oN3f2/X/B9Hq/Ee0+zVNd/9Jdz8ABKI9tPyky2SjXRcvAQghGgCxaOV+EO1BLEBPby5CiBC04cpiYWhAGRtXGGz+n8hHph9aIxUrpYySUnYEdqM9pT7sIPualPIJ4DP9vAmAlPJFG5lJUspJhUyf1UgsR7vAw4Fn85F9TpefL6XsAzyANubekLynxlxZfTz6B9t0XofZaMMp7wAd0QyC3QIHKeVfaMNrB9F6Vvt1r3Dd37EcXpRS2s45/Q00l1IO0ofQ7JBSJgLPoxm0RWg37XMFzFOs13/vR3uwuIw2H9daP7eVsdVzDu1p1Hr+on6csxH7TUoZDQzVzwsqw6fRGpOLwGE9HQFodXMzGPVf2/K/pP8GOQoLIYLJm1fpKKXsj9ajz4/H0BrNKmjG/UAh0vQAMNzm8NXdrffYcT0tdYQQFptjgO4/Eq1sqgAD0RrvE0KIp13oWq+n6Vm06+0A2jBegegjBfXQruOl5D0sPQ7gMGy7Q6/zz/T71Vr3n+nuO6SUa4AJaL3KS2hzsZDXc3kOzSgukVI+IKUciNYLsn1oAe0hMZhiYmhAGRtXJNv8r5aPTHX996CN26F8wlifLi/ov+VuMD3eDucvofWU5gD70C74FwqTTillJlrjfavSeQpYgjYhXQL43FFACPEo2tDC+2iNRw/dK7AQ8YN2g2ddR+Z7tIbLS/917F3ZEqv/Wo3NdrShila6m63MjeJYhne6EhJCVESru5low6zD0Z6mofDl4ohZ/7WtN+t/V4a3iv57RUp5Uv//VwHxN0G7FqPRhqYWCiFc5s+GEVJKL5vjuO5uvcdC9N9zaA9OdgsOpJRxaA1xc2A02nVfCpisD6c58gVQUz+crsV8eFz/XS+lvID2wAIQrg8z3hBCiFfQDN87wAjyjIy1Xq3DrtusYaSU2bYjKDomtB6nq7mpIokyNs5sQXtyA5igT7wC2kSiPvx0XHeyHbcW+q9jb8jaUBbm89rWJ1GEENanwAYOMr9LKRuh3fBhaD2X94QQrubf7NKpp73mLUinLdabepPeODjSW/+difZEZz23bSysN5qr6/FaIdLwEpphvar/jixA9g+04Y+maE/2m/WjBZrBySFvFZMj2dY/tteFDYUtwzZAZTQjEIRWLlYDdbOr3KxzQ/cJIbz0OZt7dLc9LuQT9d+y+pAN5C1YcYneIFrLpjza/N7NYG1ABwohgqSUyXoPN9FWSF9R5qP3GD5Cm7sErRfr+BAGsACth3hJ/18gehn10U/b6/Nwf+jnJdB6c5BX74517srden1PQJsTtw47WuvVOu/X3CYdJVwYzwVo1/JSfR65yKMWCDggpbwkhBiGVtmPAw2FEDvQGocOaMMV36At22wnhFiC9rTVBO3p8sd/oDtFCJGA1n3+RghxFefx9l9tJn/90Bqqs9g0hDbMAp5Bm9gsi9abMaANZcXebDodWAM8iM3kuQPWJ+4uaIaxiwuZk3raPhNC/AWML6xyIURDtAUQZ9HqZy3wphAiRkq5z1FeX1K7GW0SvyqaoTGj9QLKAX/qT7j55SUDrb6/FUKckFIWNM+RH9YyCUSbJ6jFdXqSQog6aEvxq+pOAfrikTNSylFoizoOoc1DrUC7LkLQeobrHOOTUiboy30fAFYKIXaS11C6YrQQ4qwuD5qhzK/Or8draMOuNYD9QogYNCNR00FuClBFCLFV1xemu8e66u1KKS/qC2KQUqbqk/YF0R7NYGahreSzUh1tAU4/4CO06xOgsxDiU13/T7p7TWCSEKIbMJm8uu0LhJLXk7fyBdoQand9ifhhtCFcxxWDT6O1OQ8CPwohuusjE0UW1bNxgZTy/9DmNJaj3dxPoC3LnA1c1ldytUObpG+F9pS8DG29/TmXkRaegWhDXW3QnrIXO/jHol2EfdFWgO0EeuuT5Y752I12U29Fa+RrAN8BEbfqXSEppUVKuaaApdtvoE2AB6ItZHjHhcwYtEUBEWhDSmULo1sIUQptnqg0MFxfsTRcP/9a93eFdU4mB61s9pI32es0X2NFL7MxQApawzykMOl0Ec9W4G20cfqOaAs9EgsMpPWAniBvru1O/byXHmcOWh0vRRsOvAdtkjq6gDj7os0NVEPr1XxcgOxjaCsWq6AZsy76IoQbRkppBu5DMyYX0eY5H0J7gHobWKWLzkEb2muF1vj6oT0E9i8g7l1Syl2FTIp1CG2RlLKH9UArsxzgbv1h5ge0PN+JNh9nrYPX0VYdtkS77oxoQ2e70IxQLRzKVO/9h6GVewO0cr2Iw+sUumHpiTbc2hmYl8/QYZHBS22eplAoFAp3o3o2CoVCoXA7as5GoVAoFHYIIb5Ee3cwWUrpuEjJ+nLtVLSh28vAACnlH45ytqiejUKhUCgc+QptDjU/OgO19WMQhVhqroyNQqFQKOyQUm4g76VVV3QHFugLhLYB/vqXVfJFGRuFQqFQ3ChVyFsSDtpq0ir5yAJqzsYVanmeQqG4WTy6PLlsk6E33F5VvbzK+kkfK7OklLNuXapco4yNCxLO36odBJwJrqC9+lFn7Aq36Tj0XicArl7vIy83SRn9qnFX/LY69ideKljwH1C/iva1leJQTkrH7Y3fVse/Hd2w/FPjkkje54ZAexG9wHfFikjxKBQKhcIJr9s2E7IEGCqE+A7t0zsXpZSnCwqgjI1CoVAUVbzcM2onhPgf2pcOAvRPaL2G/sV5KeUXaF9X6YL2BYXLaFt9FIgyNgqFQlFUcVPPRkr56HX8Ldzg55qUsVEoFIqiipt6Nu5AGRuFQqEoqty+OZsbRhkbhUKhKKoUoZ5N0TGLt4EdWzfxxCNd6derC/9bMMfJf++fv/Ns/0fo0Kox69eutPNbsWwx/XtF0r9XJCuWOe4SkEdrUwC/jWzNilFteKZtDSf/sVGCRS+0ZNELLYkZ2Zodr2kb/1X2L8NPwzT3X0e0onfz4Hx1bN64gW6RnYiK6MDc2c4rHjMyMhg98kWiIjrQt8/DJCYm5PrNnT2TqIgOdIvsxOZNrvcUc3f8AH/s2MzQ/tE8/3g3fv52npP//j27GDnoMXo9eB9b1q+281swcwrDn+zFsAEPMefTD8jvS+fFoZyUjn9PXXgErxI3ftwuLBbLbTlMJtMnJpPpRZvzFSaTaY7N+WSTyfSSyWS6YjKZdptMpj0mk2mLyWQSun+YyWS6qPvtNplMq3X3100mk8VkMoXaxPWi7ta0EGmznDx3zXI85bKlbbtwy/Z9Ryx/m9MtEV2iLBt3HbCcPHct99gZ97cldvtey5DhIy3f/Phrrvv+Y8mWtmHtLPuPJVsOHNf+HziebDl57prFihgTY6k7NsZy4swlS/v311sajFthOXgq1dJl8kaLGBPj8nhz8QHLjztPWsSYGEuDcSssDcatsIgxMZYmr66yJJy7bGnz1jqLGBOTq+NKpsWSfjXLEt6+veXw3/GW1EvXLFFRXS1xBw9brmRaco+vFnxjGTfhVcuVTIvl58VLLUNfGG65kmmxxB08bImK6mq5eOma5fCxeEt4+/aW9KtZbo//SmauCktcQrplz4mLljZtwy2rdxyy/HnsvKVDRKTlt017LXEJ6bnH2t//sixd/4flmSEjLLP+75dc9x9jNlu6Rj9s2XPiomXPiYuWqB49Ld8tjbXEJaQXq3JSOv41deHRdrRMizGWGz08nUbrcTt7NpvR93zXt9gNQNtl0Mr9aFs0H5VSNta3Qp6PtkOmlY26X2Mp5YM27vvI2+4VtM2Z9t9I4g4d2EeV4KpUrhJCyZIladehM1s22G94GFS5CrVqC7wcurK/b9/MPc1a4uvnR3lfP+5p1pKd2zY76bg7xI/4s5dJOHeFzGwLy/ecpn09Q75pimwUxLLd2nbymdkWMrO1J/RSPiXy7U3H7dtLSEg1gkNCKFmqFBFdIoldt8ZOZt3atXTrru2x1aFjJ3Zs24rFYiF23RoiukRSqlQpgoNDCAmpRty+vR6NH+DIoTgqVQkmqHIwJUuWpHV4J3ZsibWTMQRVpnotEyVK2F/SXl6QmXGNrKxMsjIzyM7Kwr/CXcWynJSOf09deIwi1LO5ncZmC3lbodYH4oA0IUQFIURptJ0xHT8E5wucL0Tcv6B9KA4hRC20nfDO3EjizqQkE2gIyj0PNBg5k2IuIIR9WINT2GQnOaNvGU5fvJp7nnTxKkbfMi7jrOxfhioV7mDb0bO5bkF+ZVg8/H7WjW3LnNhjJKddcwqXbDYTVCkvLQajEbPZPh/JyWaCgrRv6Pn4+FCufHkuXDiP2WzGGJQX1hhkJNkxrJvjBzh7JoWKNuVZMcDAORfl6QpRvxENGt/HwF4dGfhwJxrf15Lgao67DxePclI6/j114TG8vG78uE3ctgUCUspTQogsIURVtF7MVrQPubVEMw770LZKrSWE2A2UB+5Ae1vVShvdD+AHKeXb+v9U4KQQogGa0VlIIV46+jfTpVElVsYlkWMz3ZB08Srdp27BUL40n/Vvwoo4M2fT3fepnaLI6cR4EuKPMfv7GADeGD2YA3v/oN7d99zmlCkUt4AitBrtdqd0C5qhsRqbrTbn1nEn6zBaLeBF7L/pYzuM9jb2fIc2lNYDWHSjCQsINJCSnJR7npJsJiDQWOiwyU5hnYfHzKlXqeSX15MJ8iuDOfWqkxxAF5shNEeS065x2JxG0+oVnPwMRiNJp/PCJZvNGI32+TAYjCQlaV+ayMrKIj0tDX//ChiNRsxJeWHNSWYMjmHdHD9AxYBAztqU59kzydzlojxdsX3jOkz1GlK27B2ULXsH9zRrhTzgPOxRHMpJ6fj31IXHKEI9m9ttbKzzNg3RhtG2ofVsrPM1jiwBHihk3EuBfkC8lDL1RhNWp24DEk+e4PSpBDIzM1m36jfubxNWqLBNm7di1/atpKVeJC31Iru2b6Vp81ZOcvsSUqlW8Q6qVChLSW8vujSqxNoDzsNDNQLvxK9sSf6Mv5DrZvQtTWkfrfp8y/pwb7UKHEtx/mhl/QYNiY8/TkLCSTIzMohZvoy27cLtZMLahbNksWaPV61cQbPmLfDy8qJtu3Bili8jIyODhISTxMcfp0HDuz0aP0BonfqcTjyJ+XQimZmZbFq7gvtatnVZ9o4EGIM4sGcX2dlZZGVlsn/PLoKrOq/6Kw7lpHT8e+rCYxShOZvb/Z7NFmAU8LeUMhs4J4TwR5vDeQYo5yDfGjhamIillJeFEGOAv24mYd4+PgwbNY4xw58jJyebzlHRVK8ZyrxZnyHq1Of+B9px6EAcr40ZTnpaGls3rWf+7Bl8+b9f8PXz4/GnnuX5p7QvPvQb+Cy+fn5OOrJzLLy55CBzn7qXEiW8+On3RI4kX2JYh1DiEi6y7mAKoC8M2GP/jbtahnKMiRRY0L5p/uXG4/xlTnfS4ePjwyvjJzJ40NPk5GTTI7onoaG1mf7pVOrXb0BYeHuie/Zi/NjRREV0wNfPjw8++gSA0NDadIzoTHS3Lnh7ezNuwkS8vb09Gj+At7cPTw8bw6QxQ8jJzqF9525UrVGL/837nFqmejRr1ZbDh/bz/sSRXEpPZefWDSz86gumzvuRlg88yL4/d/LiwEfw8vKiyX33c9/9zoaqOJST0vHvqQuPUYSG0bws+bxz4AmEEN5oE/7TpJQTdLevgJZSSiGEqA4cBCRam5oBDJVSbhdChAGjpJRRDnG+DqRLKT9ycI/V5X+/TrIsaouBglFbDBSO4vBp/uKiw4N58Ox+Nu3evOEG/Mq6V2/LWNpt7dnovRlfB7cBNv+PA2XzCRsLxLpwfz0f+bCbTKZCoVD8OylCPZuik1KFQqFQFFlu95yNQqFQKG6WIvRtNGVsFAqFoqhShIbRlLFRKBSKoorq2SgUCoXC7aiejUKhUCjcThHq2dzW92z+pagCUSgUN4tn37OJ+PjG37OJeem/956NQqFQKP4BRahno4yNC8o2Geq2uK/8+Rmg3sb+L+goDnkoLjo8mQePouZsFAqFQuF2VM9GoVAoFG5H9WwUCoVC4XaUsVEoFAqF21HDaAqFQqFwO0WoZ1N0Unob+OK1vpxY8y6//zAuX5nJL/cibvFr7Fj4Co3rBOe69+3anH2LJ7Jv8UT6dm2eb/jNGzfQLbITUREdmDt7lpN/RkYGo0e+SFREB/r2eZjExIRcv7mzZxIV0YFukZ3YvGnjbdNRHPLgCR3FIQ/FRYcn8uARitC20FgsFrcdJpOph8lksphMpjr6eXX9/C0bmQCTyZRpMpk+yyeO4yaTaZ9+HDCZTG+ZTKYyul8Jk8k0zWQyxen+O00mUw2HcLv13+6FTLelTOMhljKNh1jaP/WxpUWfdy1xhxNz3WyP7kOnW2I2xVnKNB5ieaDfh5Yde49ZyjQeYqn0wGjL3ydTLJUeGG0JajPK8vfJFEtQm1GWMo2HWKxcybRY0q9mWcLbt7cc/jveknrpmiUqqqsl7uBhy5VMS+7x1YJvLOMmvGq5kmmx/Lx4qWXoC8MtVzItlriDhy1RUV0tFy9dsxw+Fm8Jb9/ekn41y3Il0+J2HcUhD6qc/ls6PJgHt7apjkeZHrMtN3p4Oo3Ww909m0eBTfqvlWNApM35w8D+68TTTkrZEGgG1ARm6u69gcrA3bp/NHDBIVxjoBcw7UYTv/mPo5y7eDlf/6i2d/Pt0h0A7Nh3HL/yZQkK8KXD/XVZs+0Q51MvcyHtCmu2HaJjq3pO4eP27SUkpBrBISGULFWKiC6RxK5bYyezbu1aunWPBqBDx07s2LYVi8VC7Lo1RHSJpFSpUgQHhxASUo24fXs9rqM45EGV039Lhyfy4DGKUM/GbcZGCFEOaA0MBPrYeF0GDgohmurnvYHvCxOnlDIdeA7oIYS4C6gEnJZS5uj+CVLK8y6C+qJtP31LqWzwJyEpL9pE8wUqG/ypHOhPgtnGPfkClQP9ncInm80EVQrKPTcYjZjNZnuZZDNBQZUAbe/0cuXLc+HCecxmM8agvLDGICPJDmE9oaM45EGV039LhyfyoHDGnT2b7kCMlPIv4KwQ4l4bv++APkKIECAbOFXYSKWUqWi9o9poRqqrEGK3EGKyEKKJg/g6IUQcsB6Y8A/yolAoFP86vLy8bvi4XbjT2DyKZlTQf22H0mKADmg9noU3EbcXaD0ZQACvADnAGiFEexu5dlLKBkBD4DO9t3XLOJV8geCgCrnnVYz+nEq+wKmUCwQbbdwN/pxKueAU3mA0knQ6Kfc82WzGaDTayxiMJCWdBiArK4v0tDT8/StgNBoxJ+WFNSeZMTiE9YSO4pAHVU7/LR2eyIOn+M8bG32IKxyYI4Q4DowGHiHPSGQAu4CRwI824bz1XspuIcSkfOIuD1QH/tLjuial/E1KORp4B+jhGEZKeRQwA84TJ/+AZev38VhUMwCaNaxOavoVks6ksmrLQR5sWQf/8mXxL1+WB1vWYdWWg07h6zdoSHz8cRISTpKZkUHM8mW0bRduJxPWLpwlixcBsGrlCpo1b4GXlxdt24UTs3wZGRkZJCScJD7+OA0a3u1xHcUhD6qc/ls6PJEHj+F1E8dtwl3v2fQCvpZSPmt1EEKsB0JsZCYD66WU54QQAEgps4HG+UWq90xmAL9IKc8LIe4BkqSUp4QQJYC7AafZOiGEAagBnLiRTMx/dwBt7q1NgH85jsS8yZtfLKekjzcAc37cRMym/XRqXZ/9S17j8tVMnn39GwDOp17m3dkxbPrmZQDemRXD+VTnhQY+Pj68Mn4igwc9TU5ONj2iexIaWpvpn06lfv0GhIW3J7pnL8aPHU1URAd8/fz44KNPAAgNrU3HiM5Ed+uCt7c34yZMxNvb2+M6ikMeVDn9t3R4Ig+e4nb2VG4Ut+xnI4RYB7wvpYyxcXsB6AyE6ENbtvIDgKZSSqfPLes9ozQ0m1wCWAS8KaW8KoSIAN4GSuviO4DndT9ruGygJDBZSvllIZJvUV99vr3xFxcdxSEPxUWHB/Pg0da/fO/5N9yApy184rZYKLV5mjPK2Nzm+IuLjuKQh+Kio7gaG98+C264AU/9rr/aPE2hUCgUhacoDaMpY6NQKBRFlaJja5SxUSgUiqKK6tkoFAqFwu0oY6NQKBQKt6OMjUKhUCjcjjI2RRzr8mR3UsYDJe9uHcUhD57QURzyUFx0eCIPHqXo2BplbBQKhaKoono2RZzjZ6+6Le7qFcsAkH7NfS/TliutXYDufkHuaPIV9ygAahnKekyHu+rCWg8XrmS7JX4A/7Lap1LOpLvvbcWAclqF/3E81W067qnuC7gvH9Y87DmZ5pb4ARqFlHdb3PmhjI1CoVAo3I67jI3+KbCpgDcwR0r5noN/VWA+4K/LjJVSLi8oTnfv1KlQKBSKIoQQwhuYjvYty3rAo0IIxy/mTwC+l1I2QdsqZsb14lXGRqFQKIoq7tlioBlwREr5t74dzHdom2HaYkHbARnAj0JsgKmG0RQKhaKIcjPDaEKIQcAgG6dZUspZNudVgJM25wlAc4doXgdWCiGGAXcCD15PrzI2CoVCUUS5GWOjG5ZZ1xUsmEeBr6SUk4UQLYGvhRANpJQ5+QVQw2gKhUJRRHHTttCJ2G90Gay72TIQ+B5ASrkVKAMEFBSpMjYFsHPbZgb26caAh6NYuGCuk/++P3cxZEBvOre5h41rV+W6H/3rEC8+049n+kbzXL9exK6OcQprZcumjTzUNYLukR2ZN9f5YSMjI4Oxo0fQPbIj/R97hFOJCQBs27qZvr0f4pGHutK390Ps2L4tXx2bN26gW2QnoiI6MHe2ax2jR75IVEQH+vZ5mERdB8Dc2TOJiuhAt8hObN600WX8v2/fzDOPdWdgn658/43z/nT7du9i2FN9iAq7l03rVjn5X76UTr+HOjLjk3fzzYMndLi7LrZu3sjD3bvQs2sn5n8522X8419+iZ5dO/HU4705lWh/fyedPkVYy3v5Zn7+ewBu27KRPg9F8kj3CL6e51rHq2NH8kj3CJ7p34fTp/J0HDksGTTgMfo+3I1+j/Tg2rUlmBQkAAAgAElEQVRrLnXs3rmFlwb25MUB0Sxe+JWT/7Kf/o9RzzzCy889yltjBpNiPg3A8aOSiS8+leu3NXbl7cvDji0MH/AQw/r34Jf/Oedh6Y/fMOKphxn1TB8mjc7LA0DsyqW88EQ0LzwRTezKpS7j9xRuMjY7gdpCiBpCiFJoCwCWOMjEA+0BhBB10YxNSkGRemQYTQjRA22HzbpSykNCiOrAMeBtKeUEXSYAOA3MzGfHzqeAEWgTUyWA8VLKxUKIFmhL9Errx0Ip5ev67p8folnkksBBoL+U0nl/ZhdkZ2cz/aN3eHfqTAIMRoYNfIwWbcKoVqNWrkxgUBAjJ7zJj9/OtwtbukwZRk98iyoh1TibkszQpx6lafP7KVfe10nHe+9MYsasLzEajfR79GHahoVTs1ZorswvP/+Ir68vi5etZMVvy5g2ZTLvffgJ/v4VmPLp5wQajBw5/BdDBz9NzOoNLvPxztuTmDl7Hkajkcd69yKsXTi1QvN0LPrpB3x9fVkas4rfli9jyscf8eHkKRw9coSY5cv4eckykpPNPPv0kyxZtgJ8vO3in/Hxu7z9yRcEBBp58Zm+tGjVlqo25WQwBvHSuEn89N0Cl2W9YM50GjS6p8C68IQOd9ZFdnY2H777Fp9+MQeD0ciAvr1p07adXfxLFv1EeV9ffvp1BStjljN96mTe/uDjXP8pkz+gZas2BeZh8ntvM2XGbAxGI0/3603rtu2oUTNPx9JfNB3fL45h9YrlzJj2MW++N5msrCwmTRjLq2++S21THS5euICPj3PzkJOdzbzpHzDu3c+oGGBk/LAnuLfFAwRXq5krU72W4O1PF1C6TBlW/foj386ZxvDx71K6dBkGj36dSlWqcu5sCuOH9uPupi25s1ze+ymeysPcT99nwvvTqRho5JUh/Wl6v0MeQuvw3oxelC5ThpVLfuSbWdMY8eq7pKde5McFs3lvxgLw8mLs4H40bfmA073tMdyw8llKmSWEGAqsQFvW/KWUcr8QYhLwu5RyCTASmC2EsLbJA6SUBb6w5qmezaPAJv3XyjEg0ub8YWC/q8BCiGBgPNBaSnk30ALYq3vPBwZJKRsDDdC7djoLpZSNpZT1gQygd2ETLA/EUTk4hEpVgilZsiRhD0awdWOsnUxQpSrUDDVRooR9MQZXrU6VkGoAVAw04FfhLi5eOO+kY3/cXkKqViU4OISSJUvRMaILsevW2Mmsj11DVLceALTv0Ikd27disVioU7cegQYjALVCa3Pt6jUyMjKcdMTt20tISDWCQ0IoWaoUEV0inXSsW7uWbt2jAejQsRM7tmk6YtetIaJLJKVKlSI4OISQkGrE7dtrF/avg3FUrhJCpcpaOT3QvhNbN9mXk7FSFWqEmijh4qnqsDzAhXPnuOe+lk5+ntTh7ro4ELeP4JCqVNHj79CpMxti19rJbIhdS2RXLf7wBzuyc8c2rDvprl+7msqVq9gZJ0cO7t9HcEhIro72HbuwMXadnczG9WvpEqUtLApr35Fduo4d27ZQq7aJ2qY6APj5++Pt7e2k44jcT1DlEIyVgvEpWZKWYR34fet6O5n6jZtSuoz28nJo3YacO5MMQKXgalSqUhWAuyoG4ut3F6kX7e8Lj+ahspaH+8M6snOzfR4a2OShdt0GnDtjBmD371u5+95mlPP1o1x5X+6+txm7d25xrgwP4aaeDVLK5VJKk5SylpTybd1tom5okFIekFK2klI20ttY191UG9xubIQQ5YDWaGN8fWy8LgMHhRBN9fPe2BsKWwxAGpAOIKVMl1Ies/E7rbtnSykPuEiDD9qKCecWPx/OpiQTaAzKPQ8INHAmxVzY4LkcOrCPrMxMKlUJcfJLNpsxGivlnhuNQaQk2+tIMSfnyvj4+FCuXHkuXLhgJ7Nm1Qrq1K1HqVKlXOoIqpSXD4PRiNlsryM52UxQkI2O8uW5cOE8ZrMZY1BeWGOQkWSHsGdTkgkw2JaTkbN643I9cnJymPPZZJ4e8lKBcp7Q4e66SE62L0uDMYiUZPs8pCSbMegy1vgvXrjA5cuXWPDVXJ5+7vkC85CSbMZgkweD0UiKwzWbkpKMwZin405dx8n443h5eTFiyDM8+Vgv/m++87AxwPmzKVQMNOaeVwwwcv5M/qMnsTGLaXTf/U7uRw7tJysrE2OlYI/n4dyZZCoabPIQaODc2fyvp7Uxi2ms5+HcGfv83xVo5FwB+Xc37jI27sATw2jdgRgp5V9CiLNCiHuBs7rfd0AfIYQZyEZbq13ZRRx7ADNwTAixBvhZSvmr7vcJIIUQsUAMMF9Kaf3eTG8hRGugEvAX8Cse5OyZFD6cNJ5RE95y6v3cKo4eOcy0KZOZPtP1jfVvZtmi72naojUBNjd+UdRhxV11MfuL6Tzatz933HHnLY3XluysbPbu/oM5CxZSpkwZXhg8EFG3Pk2btbjpODeuWc7fhw8y8cOZdu7nz55hxocTGTzq9Vt6X7gjDxtWL+dveZDXP/6ni7fcQ1H6XI0nhtEeRTMq6L+2Q2kxQAe0Hs/C/CKQUmYDEUAvNKPxiRDidd1vEtAUWAk8psdpZaE+vBYE7ANGFzbRFQMNpJiTcs/PpCQTEFj4BuvSpXQmjhrKgEHDqNvgbpcyWi8jb+LRbE7KHY6xEmg05MpkZWWRnp6Gv7+/Jp+UxKgRQ5n09vuEhFTNV0fS6bx8aE/w9joMBiNJSTY60tLw96+A0WjEnJQX1pxkxuAQtmKggTPJtuVkpmKAwXWhOHBw/x6W/ryQAQ93Zu6MT1gTs5R5X0x1kvOEDnfXhcFgX5bJ5iQCDfZ5CDQYSdZlrPH7+fuzf99ePpsymR6dH+S7//ua+XNn8cN3/+ekI9BgJNkmD8lmM4EO12xgoIFkc56OS7oOg9FIoyb34l+hAmXKlqVlqzbIQ06DBFSoGMhZm57G2TNmKgQEOsnt+2M7v/xvHqPemExJm17e5UvpfDDxRXoPeJ7adRveljzcFWDgrE2v9WxKMndVdL6e9u7azqJvv+TlNz/OzcNdAfb5P5di5i4X+fcY7nmp0y241dgIIe4CwoE5QojjaI39I+hZ1t9O3YU22fSjTThvIcRu/Ziky1qklDuklO+iGaeeVnkp5VEp5edoqyMaCSEq2qZDn7j6FXig0GmvW5/EhHiSTiWQmZlJ7OoYWrRuW6iwmZmZTBo7gvadu9ImvEO+cvXqN+TkiRMkJiSQmZnBypjltA0Lt5NpGxbO0iW/ANoQzX3NWuDl5UVaairDhz7LsOEjadwk/4nv+g0aEh9/nISEk2RmZBCzfBlt29nrCGsXzpLFiwBYtXIFzZprOtq2Cydm+TIyMjJISDhJfPxxGjS0N5ymOvU5lRBP0qlEMjMz2bBmRaHL6eWJ7zL/pxi++uE3Bj4/gvYRUTz53HAnOU/ocHdd1K3fgJPxJziVqMW/asVvPNC2nZ1Mm7btWParFv/a1Stpel9zvLy8mDXvG375bTW//LaaPn378cTAQTzcp6+Tjjr1GpBwMj5Xx5qVy2ntoKN123YsX7oYgNg1K7lX19GsZSv+PnKYq1eukJWVxe4/fqeGzQIMK7VEPZIS40lOSiQrM5Otsau4t4X9bXXsiGTOtHcZ9cZk/PzvynXPyszk40mjadO+C83btHdZTp7Kw+nEkySf1vKwJXYlTe93yMPhQ8ye8g4vT/oYvwp5eWjctCV7dm0nPS2V9LRU9uzaTuOm+c8Fuhs1jJZHL+BrKeWzVgchxHrs13BPBtZLKc8JIYDcnkxjmzCVgSAp5R+6U2PghO4XCSzXDUpttOE4+4F0jdbA0cIm3NvHhyEvvcK4EYPJyc6hY1QPqtcMZf7s6Zjq1KdlmzDkgTgmvTKCtLRUtm1az4K5M5j9f4vYsGYF+3b/QWrqRVYt11YMjho/iVr6xKUVHx8fXh73KkMHDyQ7O4fuPXpSK7Q2n0+fRr16DWjbLpzu0b14ddzLdI/siJ+fH+/oq5MWfvd/nIyPZ/bMGcyeqX2WaPoXc7mrYkUnHa+Mn8jgQU+Tk5NNj+iehIbWZvqnU6lfvwFh4e2J7tmL8WNHExXRAV8/Pz746BMAQkNr0zGiM9HduuDt7c24CROdJly9fXwYPGIsE0YOJicnh46R3alWI5Sv58ygdp16tGgdxl8H43hz/Eukp6WyfcsGvvnyc774+ufCVoVHdLijLspVDrCLf9TY8bww+BlycnLo2j2amqG1mTnjU+rWq88DYeF0i+7J6+PH0LNrJ3x9/Xnr/Y8KnX6rjhEvj+eloYPIzs4hqns0NWuFMvvzT6lTrz5t2oYT1b0nb746lke6R+Dr58cb72g6fH396PP4Ewzs3xsvLy9atmrD/W2cDbq3tw8DhrzMu+NeICcnm7CO3QipXosf5n9BDVNdmrZsy7ezp3L1yhWmvjUWgIqGIEa/8TFbN6zi0L4/SU+9yIZV2pLh50a9RvVawuN5eGrYaN4eO4ycnGzaRWh5WPjVF9Qy1aXp/W35ZtY0rl65wsdvankIMBgZ8+YnlPP1o2ffgbwypD8AvR5/mnK+fjdUT7eSojSM5mVd7eIOhBDrgPellDE2bi+gfeAtRErZwEF+ANDUcemzEKIaMA9tPucq2nru56SUR4UQ3wH3oC04yEJbEr3CYelzCbRPLgyQUl5vZtmithgoGLXFQOFQWwwUnmK0xYBHW//qw5fe8MV7fGrUbbFQbjU2RRRlbK6DMjaFQxmbwqOMzc1R48VlN3zxHpsSeVuMjfo2mkKhUBRVis4omjI2CoVCUVQpSnM26ttoCoVCoXA7qmejUCgURZSi1LNRxkahUCiKKEXI1ihjo1AoFEWVotSzUUufnVEFolAobhaPtv6ml2NuuL3664MItfRZoVAoFIWnKPVslLFxgbtehoS8FyKLsg5r/F9sPe4eBcBzLasD4IkXbN1dTp6o64TzznsZ3SqCK2gfofREfReHuvAkRcjWKGOjUCgURZUSJYqOtVHGRqFQKIooqmejUCgUCrej5mwUCoVC4XaKkK1RxkahUCiKKqpno1AoFAq3U5SMjfoQZwFs3riBbpGdiIrowNzZs5z8MzIyGD3yRaIiOtC3z8MkJibk+s2dPZOoiA50i+zE5k0bi7WO43t38tXYgXz58gB2LF3o5L9n7VIWTHiWb14dzMK3X+Js4gkAsrMyWTHnIxZMeJavX32Okwf35JuHnds2M7BPNwY8HMXCBXOd/Pf9uYshA3rTuc09bFy7Ktf96F+HePGZfjzTN5rn+vUidnWMU1hPlZMn6nrH1k088UhX+vXqwv8WzHHy3/vn7zzb/xE6tGrM+rUr7fxWLFtM/16R9O8VyYpli/PV4Yn6Lg514Qm8vG78uF3c1p6NECIImALch7aVsxl4EdgDSKAUsAF4HqgKHNTdrTQDKgBz0baaLgkcl1J2EUJUB5ZadwMVQjwDPAc8KKU8f720ZWdn887bk5g5ex5Go5HHevcirF04tUJDc2UW/fQDvr6+LI1ZxW/LlzHl44/4cPIUjh45QszyZfy8ZBnJyWaeffpJlixb4bSlclHVgU+ejpycbNZ+PZ2HRr9L+bsC+PaNYdRq0oKKVarlytRp2Y5G4VEAHP1zK+v/N5OHRr3DvtjfAOj/1kwup15g0eTxPPbap3iVsH8Gys7OZvpH7/Du1JkEGIwMG/gYLdqEUc1mf/nAoCBGTniTH7+dbxe2dJkyjJ74FlVCqnE2JZmhTz1K0+b3U668r0fLyVN1Pe2jt/lg2iwCDUE8/2QfWrZpR3WbcjIYK/Hyq2/yg0M5pV68yNdzP2fGvIV4ecHgAb25v00Y5R22PPZUfRf1uvAUqmdTCIQQXsAiIFZKWUtKeS/wCmAEjkopGwN3A/WAHnqwo1LKxjZHBjAJWCWlbCSlrAeMdaGrHzAM6FQYQwMQt28vISHVCA4JoWSpUkR0iSR23Ro7mXVr19KtezQAHTp2Yse2rVgsFmLXrSGiSySlSpUiODiEkJBqxO3bWyx1JP0t8TdWxt9QCW+fkojmYRz9c6udTOmyd+b+z7x2NfcGOXcqnpC6jQG4w9ef0neUw3z8L6c8yANxVA4OoVKVYEqWLEnYgxFs3RhrJxNUqQo1Q02UcGi4gqtWp0qI1hBWDDTgV+EuLl5wvgTcXU6eqOtDB/ZRJbgqlauEULJkSdp16MyWDevsy6lyFWrVFk6N1O/bN3NPs5b4+vlR3tePe5q1ZOe2zU46PFHfxaEuPEVR6tnczmG0dkCmlPILq4OUcg9w0uY8C9gChDoHz6USkNvHlVLa1bwQ4hE0A9RRSnmmsIlLNpsJqhSUe24wGjGbzfYyyWaCgioB4OPjQ7ny5blw4TxmsxljUF5YY5CRZIewxUVH+vmzlL8rMPe8XIUA0s87F/Pu1Uv4cvQANn4/h7C+zwMQULUmf/+5jZzsbC6mJJF8/DBpZ1Ocwp5NSSbQmJeOgEADZ1Kc83o9Dh3YR1ZmJpWqhDj5ubucPFHXZ1KSCTTkyQUajIUupzMpyRicwiY7yXmivotDXXgKLy+vGz5uF7dzGK0BsKsgASHEHUB7YKLuVEsIsVv/v1lKOQSYDiwUQgwFVgPzpJSndJlqwGdAEyll0q3OgKLwNH6wG40f7MahrWvZ/uu3RDwzmgZtOnHuVDzfvj6U8gEGKtWuh1cJ9wxHnD2TwoeTxjNqwltOvR/Fred21/d/hSI0ivavXSBgNSqbgWVSyt90d9thtCEAUsoVQE1gNlAH+FMIYX30SgHigUduNAEGo5Gk03n2Kdlsxmg02ssYjCQlnQYgKyuL9LQ0/P0rYDQaMSflhTUnmTE4hC0uOspVqEjaubyn0/TzZyhXIcApHVZE8zCO/rEFgBLe3oQ99hyPv/k53Ye/wbXL6VQIquIUpmKggRRzXjrOpCQTEOic1/y4dCmdiaOGMmDQMOo2uNuljLvLyRN1HRBoICU5Ty4l2VzocgoINJDsFNbgJOeJ+i4OdaFw5nYam/3Avfn4WY1KEynl69eLSEp5Tkr5rZSyH7ATeED3ugx0AZ4TQvS9kcTVb9CQ+PjjJCScJDMjg5jly2jbLtxOJqxdOEsWLwJg1coVNGveAi8vL9q2Cydm+TIyMjJISDhJfPxxGjR0buSKg46gGoLz5kQupiSRnZWJ3B5LzSYt7GTOJyXm/v97zw78jVoDk3ntKpnXtA9tnojbRYkS3nYTzVZE3fokJsSTdCqBzMxMYlfH0KJ1Wyc5V2RmZjJp7Ajad+5Km/AO+cq5u5w8Udd16jYg8eQJTuvltG7Vb9zfJqxQ5dS0eSt2bd9KWupF0lIvsmv7Vpo2b+Uk54n6Lg514SnUMFrhWAu8I4QYJKWcBSCEuBvwKziYPUKIcGCblPKyEKI8UAutNwOAlDJZCBEBxAohzug9oevi4+PDK+MnMnjQ0+TkZNMjuiehobWZ/ulU6tdvQFh4e6J79mL82NFERXTA18+PDz76BIDQ0Np0jOhMdLcueHt7M27CRJerVYqDjhLe3oQ/PoSfPxqHJSeH+m06ElClOlt+no+xholaTVqye80S4vf/gbe3D6XvLEenZ0YB5K5I8vLy4s4KFYkY9LLLuvD28WHIS68wbsRgcrJz6BjVg+o1Q5k/ezqmOvVp2SYMeSCOSa+MIC0tlW2b1rNg7gxm/98iNqxZwb7df5CaepFVy5cAMGr8JGqZ6ni0nDxR194+PgwbNY4xw58jJyebzlHRVK8ZyrxZnyHq1Of+B9px6EAcr40ZTnpaGls3rWf+7Bl8+b9f8PXz4/GnnuX5px4FoN/AZ/H1c74VPVHfxaEuPEVRGka7rZunCSEqoy19vhe4ChxHW/q8yLpk2Ua2OjZLmW3cRwNPAlloPbV5UsrJLpY+NwKWA9FSyh0FJMtSlD//7wkdaouBwqG2GCg8xWiLAY82/83fXX/DDfj2V9r+9zZP0yfyXc2nNHAhezwf9w+BD68nr690cx4gVigUiiJKUerZqM/VKBQKRRGlKL3UqYyNQqFQFFGKkK1RxkahUCiKKqpno1AoFAq3U4RsjTI2CoVCUVRRPRuFQqFQuJ2iZGxu63s2/1JUgSgUipvFo61/208233B7tX5Eq//eezYKhUKhuHmKUs9GGRsX7E+85La461fR9vpIv+a+DlS50toF6O63sS9cyXaPAsC/rPYJkDpjC/V1oZvi0HudgGLx1rpHdHiivotDXXiSImRrlLFRKBSKoorq2SgUCoXC7RQhW6OMjUKhUBRVShQha/Nv3TxNoVAoFMUI1bNRKBSKIoq7Ojb6HmBTAW9gjpTyPRcyjwCvo70uskdK+VhBcaqeTQH8sWMzQ/tH8/zj3fj523lO/vv37GLkoMfo9eB9bFm/2s5vwcwpDH+yF8MGPMScTz8gv/eZtmzayENdI+ge2ZF5c2c5+WdkZDB29Ai6R3ak/2OPcCoxAYBtWzfTt/dDPPJQV/r2fogd27flm4/NGzfQLbITUREdmDvbtY7RI18kKqIDffs8TKKuA2Du7JlERXSgW2QnNm/a6DL+rZs38nD3LvTs2on5X852Gf/4l1+iZ9dOPPV4b04lJtr5J50+RVjLe/lm/pf55qG1KYDfRrZmxag2PNO2hpP/2CjBohdasuiFlsSMbM2O17SdFyv7l+GnYZr7ryNa0bt5cL463F1O7o7fUzo8Ud/FoS48gTt26hRCeAPTgc5APeBRIUQ9B5nawCtAKyllfbR9yArkX2dshBBGIcS3Qoi/hRC7hBBbhRDRQogwIcRFIcRu/VitywshRKzudlAIYd31M0wIsdQm3reEEDFCiNKFSUd2djazp77PhPc+Zeq8n9i4NoaTx/+2kwk0VmLYmNdp0z7Czv1Q3B4Oxu3h4zkLmTL3B47I/ezfs8uljvfemcS0z2fz4y9LWfHbMv4+esRO5peff8TX15fFy1bSt98TTJsyGQB//wpM+fRzvv/5V9546z0mjne962F2djbvvD2JGV/MYdGSZcQsX8rRI/Y6Fv30A76+viyNWcXj/Qcw5eOPADh65Agxy5fx85JlzJg5h3feeoPs7Gyn+D989y2mTJ/Jdz//ysqY5U55WLLoJ8r7+vLTryvo8/gTTJ862c5/yuQPaNmqjcv0A5Twgond6/LMvF1EfbKJyMaVqGW4007mvaWS6GlbiZ62lW+2xrNqvxmAlLRr9JmxjehpW+k9fRuDwmpiKO98CXiinNwZvyd1uLu+i0NdeIoSXjd+FIJmwBEp5d9SygzgO6C7g8wzwHQp5XnQdkS+blpvLGvuRQjhBfwCbJBS1pRS3gv0AayPoxullI3140HdbRrwie5WF/jURbwTgFZou3ReK0xajhyKo1KVYIIqB1OyZElah3dix5ZYOxlDUGWq1zJRooR9MXp5QWbGNbKyMsnKzCA7Kwv/Cnc56dgft5eQqlUJDg6hZMlSdIzoQuy6NXYy62PXENWtBwDtO3Rix/atWCwW6tStR6DBCECt0Npcu3qNjAzn3Rrj9u0lJKQawSEhlCxViogukU461q1dS7fu0QB06NiJHds0HbHr1hDRJZJSpUoRHBxCSEg14vbttQt7IG4fwSFVqaLnoUOnzmyIXWsnsyF2LZFdtTyEP9iRnTu25fb01q9dTeXKVahZK9Qp7VbuDvEj/uxlEs5dITPbwvI9p2lfz5CvfGSjIJbtTgIgM9tCZramq5RPiXyHHdxdTu6O31M6PFHfxaEuPIU7ejZom0yetDlPwHnjSRNgEkJsFkJs04fdCuRfZWyAcCBDSvmF1UFKeUJK6WRAbKiEVhhW+X22nkKIkWjdwa5SyiuFTcjZMylUNATlnlcMMHAu5brGW9NZvxENGt/HwF4dGfhwJxrf15LgajWd5JLNZozGSrnnRmMQKclmO5kUc3KujI+PD+XKlefChQt2MmtWraBO3XqUKlXKpY6gSnn5MBiNmM32OpKTzQQF2egoX54LF85jNpsxBuWFNQYZSXYR1lbGYAwiJdm+nFKSzRh0GWseLl64wOXLl1jw1Vyefu55p3TbYvQtw+mLedtDJ128itG3jEvZyv5lqFLhDrYdPZvrFuRXhsXD72fd2LbMiT1Gcprz84bby8nN8XtMhwfquzjUhafw8rrxQwgxSAjxu80x6CZU+wC1gTDgUWC2EML/egH+TdQH/ijAv40QYrf+/wcp5dvAJ8BaIcQWYCUwT0ppbY1bAQK4V0qZ7q5EO3I6MZ6E+GPM/j4GgDdGD+bA3j+od/c9t1zX0SOHmTZlMtNnzr3lcbub2V9M59G+/bnjjjuvL1xIujSqxMq4JHJspsiSLl6l+9QtGMqX5rP+TVgRZ+ZsunMvUOFe3FHf/3W8buJTbFLKWYDzRFUeiUCIzXmw7mZLArBdSpkJHBNC/IVmfHbmF2m+xkYIsYgCPkoppXyogMTeEoQQ04HWQAYwGm0YLcohHfOEECuACLRxxWeFEI107yNABaAD8NON6K4YEMjZ5KTc87NnkrkrMP+hG1u2b1yHqV5Dypa9A4B7mrVCHtjrZGy0J6rTuedmc1Lu0JiVQKMBs/k0xqAgsrKySE9Pw99fe4AwJyUxasRQJr39PiEhVV2mxWA0knQ6Lx9ab8peh8FgJCnJRkdaGv7+FTAajZiT8sKak8wYXIS1lUk2JxFosC+nQIOR5KQkjMa8PPj5+7N/317WrVrJZ1Mmk5aWRokSXpQuXZqH+/S1C29OvUolv7yeTJBfGcypV3FFl0ZBvPnLQZd+yWnXOGxOo2n1CqyIs38adXs5uTl+j+nwQH0Xh7rwFIWcg7lRdgK1hRA10IxMH8BxpdkvaD2aeUKIALRhtb8pgIKG0T5DW5GQ3+EO9gO5LbKUcgjQHggsKJCU8pSU8kspZXcgC2ige5mBLsAUIUS7G0lIaJ36nE48ifl0IpmZmWxau4L7WrYtVNgAYxAH9uwiOzuLrKxM9u/ZRdc7B4MAACAASURBVHBV5xVU9eo35OSJEyQmJJCZmcHKmOW0DQu3k2kbFs7SJb8A2nDZfc1a4OXlRVpqKsOHPsuw4SNp3CT/HlP9Bg2Jjz9OQsJJMjMyiFm+jLbt7HWEtQtnyeJFAKxauYJmzTUdbduFE7N8GRkZGSQknCQ+/jgNGt5tF7Zu/QacjD/BqUQtD6tW/MYDbe2Luk3bdiz7VcvD2tUraXpfc7y8vJg17xt++W01v/y2mj59+/HEwEFODQ/AvoRUqlW8gyoVylLS24sujSqx9oDzkGaNwDvxK1uSP+PzhhmNvqUp7aNd5r5lfbi3WgWOpTh/+87d5eTu+D2lwxP1XRzqwlO4Y85GSpkFDAVWAAeB76WU+4UQk4QQ3XSxFcBZIcQBYB0wWkp51nWMGvn2bKSUuTNmQohSQFUp5ZH85G8Ra4F3hBCDpZSf6253FBRAn5haI6XMFEIEARXRrHEdACnlX0KIh4BfhBCRUsrdBUSXi7e3D08PG8OkMUPIyc6hfeduVK1Ri//N+5xapno0a9WWw4f28/7EkVxKT2Xn1g0s/OoLps77kZYPPMi+P3fy4sBH8PLyosl993Pf/c6GysfHh5fHvcrQwQPJzs6he4+e1AqtzefTp1GvXgPatgune3QvXh33Mt0jO+Ln58c7H3wMwMLv/o+T8fHMnjmD2TNnADD9i7ncVbGik45Xxk9k8KCnycnJpkd0T0JDazP906nUr9+AsPD2RPfsxfixo4mK6ICvnx8ffPQJAKGhtekY0Znobl3w9vZm3ISJeHt7O8X//+ydeVyU1f7438hA7uDGoELm9pzcWsxrVpYIISjgblqW9S1bNNNKLdO0bnfptu+WmUtme1maW5q75p4mGB5XRFAGVEBAEHDO748ZRsYBRe+dgeF33r7Oy3nO+ZzzOZ/zDM9nznO2CZOmMHbUo1itVuL6DaBVm7bMmP4B7dp34K6wcPoOGMTLU55nUFwU9esH8s/X3qzILXBw3qr4x6JEZj18CzVq+PDjjlQOpufxVGQbElKyWZOYAdgnBvx5wilv66C6PB8jUNj2fp+9IYn9Ftc3qp5oJ3eW70kd7r7f1eFeeAp3rbORUi4Fll4UN63UZwU8aw8V4rLn2QghYoC3AX8pZUshxE3AS1LKAVdQ9wojhGiKbRzmViADyAM+wdZLmXDxazQhxNtADFDyXuUNKeV8IURYaXkhRC/gM6CnlPLQJaqg9K7Pl0bv+lwx9K7PFaca7frs0f1jBs7aecUPkgWP3FJlz7N5BduDfw2AlHK3EKL8eYv/JVLKE9jeEZbF2jLky/SuUsq1peWllCuAsgc2NBqNxgvxoq3RKjT1uajU7K4S9GmWGo1GU8m4aZ2NW6hIzybRvgdODfvshLFA+XujaDQajcYjVLeezRjgFsAK/IRtGvJl98HRaDQajXup4eNzxaGyuGzPRkqZBzwvhPg7oK5kFb5Go9Fo3IcXdWwu72yEEJ2BWdjXugghLMCjUspLrfTXaDQajZvxpmOhK/IabQ7wrJQyREoZAoy3x2k0Go1GUyEq4mysUso1JRf2KcVWt9VIo9FoNBXCTUcMuIVyF3UKIUr2YPg/wB/4GtuU56HYpkOP90gNPY+e1q3RaK4Wjz7O75//5xU/r+bff2OVW9R58f5npTcA0g9kjUajqWS8aMjmknujlX+UXjWnumwv4q4tcdy9HQ54tp1G/fiXW8r/eJDtJN0/ks64pXyAztfVB6rPvXD3d3bb4Wy3lA/QtVWA28ouD2+aIFCh82yEEFHYzppx7PMupfy3uyql0Wg0mstTmWMwV0pFpj5PBwKBu7DNQhuE3kFAo9FoKh1v6tlUZDZadynlfcApKeVUbJtyum0jTo1Go9FUDJ+rCJVFRV6jlewYUGA/L+YU0Mx9VdJoNBpNRajM7WeulIo4m2VCiEDgTWA3cB743K210mg0Gs1l8SJfc/nXaFLKl6WUWVLK74GWQCfgR7fXrAqwacN6+sZEERsdyayZn7qkFxYWMnH808RGRzJ82BBSU1McabNmziA2OpK+MVFs2rihUnX8vnEDA+Oi6RfTizmzytYxaeIz9IvpxYj77uG4XceWzZsYPnQg9wyMY/jQgWzbWvZQXXVpp/bmOrzcqzV/j2pDL6ORS3q3FgG8HmswOaIVkyNaccd1gY60MXdcy1txgtG3h5Zb/u7tv/PsI4N4+qEBLPx2rkv6kh+/ZMKj9/DcE/fyz+dHkWGxnTqadEgy7emHHWmb164oV0d1uBfu/r4C7NmxmYkjBzP+4YH88p3rb+dlC77k+ceGMnnUfbw6aTQnLc4nwObn5TL2/lg+n/5GuTo8gTcdMYBS6oqDYRjJV5PvMmWeNwxjt2EYCYZhfG8YRu1Saf0Nw1CGYVxfKu46e9w/S8U1NgyjyDCMDy8qe5BdtksF6qLyi5TKLShW4RER6sDhZHUm75yKjY1TCYkHVH6RcoS58+aryS9OVflFSi1YuFiNGTtO5RcplZB4QMXGxqnsvHPqwJFkFR4RoXILilV+kXLgCR05BVaVlVekeoZHqMSDR9XpnAIVExun/ty7X+UUWB1h1tz56oUpU1VOgVX98NMv6smnxqmcAqvavitBHU4+oXIKrGpX/D51R/fuKqfA6lEbPKHjiR/2qlE/7FXpOefUi8v2qyd/3KuOZearl389oJ74Ya8jzN2eotYcPOUUVxLeWZekPtp0VO05fsYRV8LOI9lq+8HTqnuPnmrp73vV1v0n1d1RMWrh2l1q55FsR5j30yr1e6JF7TySrf7z/iw1YuRotfNItlq8YY9avDFe7TySrVbuOKi6drtNrY9PUTuPZFe7e+GO72vp7+zWQ1lq8/5TqvtdPdUvG/eqTfsyVERUH7Vg9R9q66EsR5iz4De1fm+a2nooS/3rvc/UAyNHO6WPmThVPfjYGDV6/BRHnJ3/6XPxcuGx7xPUlQZP17EkVGSCQFm4wz3mSylvklJ2xHaMwROl0u4FNtr/L80RbEdClzAE2FtaQAhRDxgHbL2SyiTE7yE0tAUhoaH4+fsT3SeGtWtWOcmsWb2avv1sp2NH9opi25bNKKVYu2YV0X1i8Pf3JyQklNDQFiTE76kUHXsT9hB67bWEhITi5+dPr+g+LjrWrV1FbN/+AERERrFtq03H9e3a0yTIDEDrNm05V3COwsLCatlO1zWsRUZeISfzijivYEdKNjc2q+ciVx4yI4+CovJ3cToo9xLcLBRz0xBMfn7cFhbJjs3rnGQ63NSFa2raVhe0adeJ0yfTAWga0oKmzW2HzDZs1IT6AQ05k51ZKe3kbh3u/r4CHNq/F3OzEIKaNsfk50e3Hr3YuWW9k0z7G0vdi+sv3AuAIwcSyc48TcfO3VzK9jTedMTA1Tobd+8gsAH7jDchRF2gO/AIrsdFn8V2uFsX+/VQ4LuLZP4BvAYUXEkF0i0WgpsGO66DzGYsFouzTLqF4OCmAJhMJurWq0dWViYWiwVz8IW85mAz6Rfl9aQOs7npBTlzMBnpznIZlnSHjMlkom7demRlOR/Oumrlr1zfrj3+/v6VYoO7dQTWMpF5tshxnZlfTGAtPxe5m5vVY8rdrXj01hAa1KrQMjVbeacyaNTE7Lhu1NhM5smMcuXXLl/IjX+73SX+4L69FBcXYW4a4pJWHe6Fu7+vAJknM2hY6l40bBxE5qny78W6FYu4octtAFitVr6a+R73jRxbrrwn8fG58lBZlPvXIoT4ibKdig/g+kL7f4QQwgT0Bpbbo/oBy6WU+4UQp4QQt0gpd5bK8g0wzH70wXngOPbZcvbjEUKllEuEEBPdVefqzqGDB3j/3bf4aMasyq5KpRJ/Ipcdx85QbFV0bxnIg12a8+6Go/9zPRtWLeXwgUSmvTHDKT7z1EmmvzGNURNepkaNq/2dWP35X35fN61expH9iUx5/RMAVi3+gRv/druTs6pMvGmdzaV+mn14lWlXSy0hxG775w3YztAB26uz9+yfv7Ffl3Y2y7H1XizAtyWRQogawNvAQ1dTmSCzmbQTaY5r2y8u5y9YUJCZtLQTmIODKS4uJjcnh8DABpjNZixpF/Ja0iwEmV2/nJ7SYSk1uGmxpDleNZTQxByExVJKR24OgYGB9nLTmPDMGF7512uEhl5bbdspK7+YBrUv9GQa1DKRlV/kJJNXeN7xedORLAZ2qvgDp0GjJpzKuPAL/dRJCw0aN3GRi/9jKz9/PYdpb87Ar9Sv8rN5ubw+7WmGPjSatu06lamjOtwLd39fARo0bsLpUvfi9Ml0GjRyvRcJu7ax6Js5TH79E8e9OJAYz/69u1m1+EcKCs5SXFRMzZq1GPrwmDJ1uRtv+slRbl2llKsuFdxQl5Ixm5uklE9JKQuFEA2BcOAzIUQSMBG4RwjhcOdSykJszmc88EOp8uoBHYG19rzdgEWlXrldkg4dO5GcnERKyjGKCgtZvnQJPXqGO8mE9Qxn0cKfAFi54le63toNHx8fevQMZ/nSJRQWFpKScozk5CQ6drqhUnS079CJY0ePkpqSQlFRISuWL6VHmLOOHmHhLF70M2B7/fC3rjYdOWfOMG7M4zw1bjw33dy5WrfT0cx8gur606i2H74+0CUkgD3Hc51k6te88Nvshmb1SDtzrsw2KYvWoj1pqcmkp6VSXFTE5rUruaXbXU4yRw5KPnv/VSb8/S0CAhs64ouLinj7lYncGdGHW++MKFdHdbgX7v6+ArQy2pN2/JjjXmxZt4LO3Zy3gkw6KJnz/qs889KbTvdi9PP/4N15v/DO5wu5d+Q4ut/dp9IcDXjXbLSKv3SuHAYDX0gpHy+JEEKsA+4EkkvJvQWsk1KeFkIAIKXMBhqXyrcWmCCl3FERxSaTiRemTGPUYyOxWs/Tf8Ag2rRpy0cfvEeHDh0JC49gwKDBTJk0kdjoSOoHBPD6m+8A0KZNW3pF92ZA3z74+voy+cVp+Pr6VpqO5yZPZcyoRzh/3kq//oNo3aYtH3/0Pu3bd6RHz3D6DRjM1MnP0S+mFwEBAfz79bcB+PabLzmWnMzMGdOZOWM6AB99Mou6zRp73AZ367Aq+GZ3Gk91v5YaPj78npTFiZxzxLZvQnJmPntO5NKzdUNuaFYXq9XWy/l853FH/vE9rsNcz59rTDX4d++2fPHHcafyfX1NPPTkc7w6eSxW63nCevUl9LrWfP/5J7Q02tHlth58NfM9CvLzee+fkwBoFBTMxL+/zeb1K9kXv4vcM9msX7kYgCcmvMR1rUW1+8664/vasJHzW39fXxMjRk3kjRfHYj1v5a5ecYS0aM2P82bQ0mhH52538c2s9ykoyOeDf79guxdNgnn25bdc2kNTcco9z8bTCCFypZR1L4pbA7wmpVxeKm4s0A7boP9i++y10nkeArpIKcdcFL+WijkbpXfQvTR61+eKoXd9vnId1WDXZ492HZ5euO+KG+zdftdXufNsnBBCXCOlrPh7gyvkYkdjj+tZRtz7pS47lpE+F5hbRnzYf1VBjUajqWJ4067Plx1fEkJ0FULEAwfs1zcKIT5we800Go1Gc0m8acymIpMZ3gdisW3AiZTyT8Clx6HRaDQaz1LD58pDpdW1IjJSyosXE5wvU1Kj0Wg0HqNaLOosxTEhRFdACSF8gaeA/e6tlkaj0WguR3U7YmAUtldp12JbOPmbPU6j0Wg0lYg3Leq8rLORUqbjuieZRqPRaCoZL+rYXH6djRBiJmXskSalfMxdlapkqsbCI41G44149PE/dfmBK35e/SO6bZVdZ/Nbqc81gQHAMfdUR6PRaDQVxZt6NhV5jfZt6WshxBfYzpaptlSX1dju0lEdVpTDhVXljR782i3ln/rcdvxS2pmiy0hePcH1bZuHeqKdsvLdNwk1sJZt25rqsOuFJ/GmRZ1X0zwtgaqxv7ZGo9H8f0y1mo0mhMjkwjhGDeA0MMmdldJoNBrN5fEiX3NpZ2Pfyv9GINUeZZVS6gF0jUajqQJUm9doUkolhFh68c7KGo1Go6l8fDw7+e2/oiJrgnYLIW52e000Go1Gc0V4095o5fZshBAmKWUxcDOwXQhxCMjDNo9cSSnLPwpPo9FoNJpSXKpns83+f19AAH2AIdhOzxzi5npVCTZtWE/fmChioyOZNfNTl/TCwkImjn+a2OhIhg8bQmpqiiNt1swZxEZH0jcmik0bN1RrHZ6w4feNGxgYF02/mF7MmVW2jkkTn6FfTC9G3HcPx+06tmzexPChA7lnYBzDhw5k29Yt5eoI79SUrf+JYfvrsYyLaeeS3rxhbX6eFM6aV6JZ/8/e3H1DUwDCOgSz6u9RbPhnb1b9PYo725U9WXPr7xu5f1As9w3ozZdzPyvThpdfGM99A3rzxEP3cuK4bai0uLiIf788mYeGDeCBIXHMnzOzUttp86YNDOnXh0FxUXw+27UuhYWFTHnuWQbFRfHw/UM5nprqlJ524jhht93C/M9nV5oNnvjOegJv6tmglCozGIaxq7w0dwfDMM4bhrHbMIw/DcP4wzCM2+3x1xmGkW9P+8swjE8Mw6hhD+8bhpFgGEa8YRjbDcNoac+TZBhGY/vnWwzDOGIYxs2X0K/yi5TKLShW4RER6sDhZHUm75yKjY1TCYkHVH6RcoS58+aryS9OVflFSi1YuFiNGTtO5RcplZB4QMXGxqnsvHPqwJFkFR4RoXILilV+kXLgzTo8aUNOgVVl5RWpnuERKvHgUXU6p0DFxMapP/fuVzkFVkeYNXe+emHKVJVTYFU//PSLevKpcSqnwKq270pQh5NPqJwCq9oVv0/d0b27I08JDUd8pRo/+LU6bDmjbh6/UJn/7xsVf/S0um3SYtVwxFeOMHfNATV+7jbVcMRX6rZJi9XR9BzVcMRXqseLy1T7sT+phiO+Ure/sEQdP52nGo74ylH+iexClXI6X4X1DFc79x5SySfzVO+YWLV5V6I6kV3oCNM/m6cmTJqiTmQXqvnf/6weH/2UOpFdqOZ9+5N64smx6kR2oTpiyVZ39QhTfyQeUSeyCz3aTplni9XJnHOqZ3iESth/RKVnn1V9YuPUzvh9KvNssSPMnPOFen7yiyrzbLH6dsEiNXrMWKf0x0ePUU+MHqM++PhTR1wJ7rbBA99Zjz4rX19zSF1p8HQdS8KlejZNhBDPlhfc7APzpZQ3SSlvBF4AXi2VdkhKeRNwA9Ae6A8MBZoBN0gpO2Hb5SCrdIFCiBuAH4ChUspdl6tAQvweQkNbEBIaip+/P9F9Yli7ZpWTzJrVq+nbbwAAkb2i2LZlM0op1q5ZRXSfGPz9/QkJCSU0tAUJ8XuqpQ5P2LA3YQ+h115LSEgofn7+9Iru46Jj3dpVxPbtD0BEZBTbttp0XN+uPU2CbD2N1m3acq7gHIWFhS46OrdqyBFLLkcz8ig6b+Wnrcn07hziJKMU1KtpW0RZr5YfaVn5AMQnZzo+70vNpqafL/4m5z+txL3xNA+9lmYhofj5+REe2ZuN61Y7yWxav5qomH4A9AjvxR/bt6KUwsfHh/z8fIqLizlXcA6Tnx916rgcbOuRdvorIZ6Q0GtpbtcRGdWb9Wud7Vi/djUxcTYd4Xf3Yvu2LSj7tljrVv9Gs2bNadW6jUvZnrLBE99ZT+FNPZtLORtfoC5Qr5zgKeoDmRdH2seTfgfaAE2BE1JKqz0tRUpZOk874GfgASnltovLKot0i4XgpsGO6yCzGYvF4iyTbiE42PYqxWQyUbdePbKyMrFYLJiDL+Q1B5tJvyhvddHhKRvM5qYX5MzBZKQ7y2VY0h0yJpOJunXrkZXl9HuDVSt/5fp27fH393fR0bRBbVJPn3VcHz99lqYNajnJvP5TPENuv474d/rx7fgwJs3f6VJOXJdQ9hzNpLDY6hR/MiOdIPMFW5uYzZzMSHeWSb8gYzKZqFO3LtnZWYRFRFKrVi0G9u7JPXGRDB3+EPUDAiqlndLTne9ZkDmYjHRnOzLSLQQFX7Cjbt16ZGdlcfZsHvPmzmLkE6NdyvWoDR74znoKd51nI4SIFkJIIcRBIUS56yqFEIOEEEoI0eVyZV5q6vMJKeUrFava/5xaQojd2PZiawqEXywghKgNRADTgHhgoxDiTmAVMP+i3stC4H4pZbXeZkdTPocOHuD9d9/ioxmzrrqMgd1a8PXGI0xfvo8urRvx8WO3cceUpZTsZSua1+eloTcy+I21/5tK20ncG0+NGr4sWLaanDNneOrRB+nStRvNQkL/p3rgf9NO5THzk4+4d/gIateu8z8vuzTutKGq4Y4dBOznln0ERAIp2CaILZJS/nWRXD1gHLC1IuVeqmdTmUNJJa/RrgeigXn2BaYAre2OaBOwREq5TEqZgm0SwwuAFVglhIgoVd5vwEh7I1aIILOZtBNpjmvbLy7ngd+gIDNpaScAKC4uJjcnh8DABpjNZixpF/Ja0iwEmV0HjauDDk/ZYLGcuCBnSXO8LimhiTnIIVNcXExubg6BgYH2ctOY8MwYXvnXa4SGXutSPsCJzLM0b1jbcd2sYW1OZOY7ydzfozU/b0sGYMehU1zj50ujutfY5BvUYt7YOxn96RaS0nNdym/cJIh0ywVbMywWGjcJcpYJuiBTXFxMXm4uAQGB/LZ8KV1vvwOTyY8GDRvR8cab2Je4t1LaKSjI+Z6lW9JoEuRsR5MgM+lpF+zIzc0hIDCQvfF7+PDdt+jf+26++fILPp/1Kd9/86XnbfDAd9ZTuOk1WlfgoJTysJSyEPgG6FeG3D+A14CCCtX1EmkRl0jzGFLKzUBjoIk96pDdEd0spXy5lNw5u+OZCPwb21hOCWPs/0+vqN4OHTuRnJxESsoxigoLWb50CT16OnewwnqGs2jhTwCsXPErXW/tho+PDz16hrN86RIKCwtJSTlGcnISHTvdUC11eMKG9h06cezoUVJTUigqKmTF8qX0CHPW0SMsnMWLfgZsr1D+1tWmI+fMGcaNeZynxo3nppvLn62/68hpWpnrcW3jOvj51mDArdeybFeKk0zKqTx6tLc9WIym9anpV4OTOeeoX9uPr5/twT+++5NtB06WWf717TuSkpzMidQUioqKWL1yGXfc1dNJ5o47e/LrkoUArFu9gpv/dis+Pj6Yg5vyx3bb29/8/LP8lbCHFte1rJR2atehI8eSj3I81aZj5a/LuKuHsx139ujJkl9sOlb/toIudjs+nTOfn5f9xs/LfmPY8Ad48JHHGDJsuMdt8MR31lO46TVac5x39k+xxzkQQnQGQqWUSypa13Jfo0kpT1e0EHcihLge2/jRKaB2OTKdgTQp5XEhRA1skwdKj9pZgfuAX4UQr0gpp11Or8lk4oUp0xj12Eis1vP0HzCINm3a8tEH79GhQ0fCwiMYMGgwUyZNJDY6kvoBAbz+5jsAtGnTll7RvRnQtw++vr5MfnEavr6unarqoMNTNjw3eSpjRj3C+fNW+vUfROs2bfn4o/dp374jPXqG02/AYKZOfo5+Mb0ICAjg36+/DcC333zJseRkZs6YzswZtt8aH30yi4aNGjnpOG9VPP/FDr6fGIZvDR++Wn8YmXqGSQM6sTvpNMt3pTLt612883BXnogSKAVPfmZ7e/Do3QYtzfWY0K8jE/rZNtsY/MYaFxuefm4yE8Y+jvX8efr0HUDL1m2Y9cmHXN+uA3f06EmffgP510svcN+A3tSrH8BL/3oDgP5D7uU/r7zIg/f0Q6HoHdef1m1FpbSTyWRiwqQpjB31KFarlbh+A2jVpi0zpn9Au/YduCssnL4DBvHylOcZFBdF/fqB/PO1N13qWh6essHd31lPUeMqXkAJIR4DSp9H9qmU0nX+d/n5awBvAw9did7LHp5WGQghzmMbhwHb67zJUsolQojrgMUXb58jhIgG/gVcY4/aBoyWUhYIIZKALlLKk0KIAGAdMFNK+VE56pU3b//vCR36iIGKoY8YqDjV6IgBjw4/TP896YobbPTt112yjkKI24CXpZRR9usXAKSUr9qvA4BDQMn74mBsGzT3lVLuKK/cSjiB4fJIKcv8qSClTAJc9mmTUi4HlpeT57pSn7OBm/4nldRoNJpKxk1TmbcDbYUQLbFtwjwM25shwPEcbVxyLYRYC0y4lKOBiu2NptFoNJoqSA0fnysOl8O+rGQM8CuQCHwnpdwrhHhFCNH3autaJXs2Go1Go7k87jrPRkq5FFh6UVyZY91SyrCKlKmdjUaj0Xgp1eqkTo1Go9FUTbzI12hno9FoNN6KNw26a2ej0Wg0XoqPF3VtquQ6m0pGN4hGo7laPPr0n7fj2BU/r0Z0Ca0UD+VNvTCNRqPReCn6NVoZePPqfk/oKCnfEyvKq0M7ebMNpXVsO5ztNh1dW9mOTJi7Pdkt5T/0N9umnF/9kXIZyavnvovOP/IEejaaRqPRaNyO97ga7Ww0Go3Ga/Gijo12NhqNRuOteNNsNO1sNBqNxkvxphle2tloNBqNl6J7NhqNRqNxO97jaryrF+ZxNm1YT9+YKGKjI5k10/Ugu8LCQiaOf5rY6EiGDxtCauqFaZWzZs4gNjqSvjFRbNq4oVrr2LxpA0P69WFQXBSfz55ZZvlTnnuWQXFRPHz/UI6npjqlp504TthttzD/89mVZoMndFQHGwD27NjMxJGDGf/wQH757nOX9GULvuT5x4YyedR9vDppNCctJ5zS8/NyGXt/LJ9Pf6PM8g/9uZ0ZE/6Pj599kM2LvnFJ/2PVL3w26VFmTX6cL155mpOpRwFI2LSKWZMfd4RXH+iF5ejBMnUc3L2ND599kPeffoCNC10Pz9ux8hc+fm4kn0x6jNkvjyMjJQmArIw0/jWiN59MeoxPJj3G4s/eKbedPIGPj88Vh0pDKVWlgmEYIYZhLDQM44BhGIcNw/jQMIxrDMMIMwwj2zCM3YZhJBqG8ZJdvrZhGF8ahhFvGEaCYRgbDcOofGXkKwAAIABJREFUa0/LLVVuH8Mw9huG0eIydVD5RUrlFhSr8IgIdeBwsjqTd07FxsaphMQDKr9IOcLcefPV5BenqvwipRYsXKzGjB2n8ouUSkg8oGJj41R23jl14EiyCo+IULkFxSq/SDnwZh0lZJ4tVidzzqme4REqYf8RlZ59VvWJjVM74/epzLPFjjBzzhfq+ckvqsyzxerbBYvU6DFjndIfHz1GPTF6jPrg408dcdWpnbzZhtI6th7KUpv3n1Ld7+qpftm4V23al6EiovqoBav/UFsPZTnCnAW/qfV709TWQ1nqX+99ph4YOdopfczEqerBx8ao0eOnOOJKmLXlsOravYd6e/EW9dnvB1X3u6PVGz+tV3O2HXWET9b+5fg8+eOvVdSg+5zS52w7ql77ca3q2r2H47qEL3ceU19sT1K3du+hPly6Vc3beljdeXe0enfhBvXlzmOOMHvDPsfnaTO+Vb0HD1df7jymPlq+Xd0R3stJtiTY8ejz8sfdx9WVBk/XsSRUqZ6NEMIHWAD8LKVsC7QFagGv20U2SClvAroA9wshOgPjAIuUspP9uOhHgKKLyo0A3gd6SymPVqQuCfF7CA1tQUhoKH7+/kT3iWHtmlVOMmtWr6ZvvwEARPaKYtuWzSilWLtmFdF9YvD39yckJJTQ0BYkxO+pljr+SognJPRamoeE4ufnT2RUb9avXe0ks37tamLi+gMQfncvtm/bgrJvk7Ru9W80a9acVq3bVOt7UR1sADi0fy/mZiEENW2Oyc+Pbj16sXPLeieZ9jd24ZqaNQFoc30nTp9Md6QdOZBIduZpOnbu5lI2wPFDkgbmZjQIaoqvyY923cLYv/N3J5lratdxfC48V1Dmr/W/fl9N+25hZepIPbiPhsHNaWBuhq/Jjw639WTfjsvpKLOoSsebejZVytkA4UCBlHIOgJTyPPAMMAKoWyIkpcwDdgJtgKbYji4tSZNSynMl10KIu4CZQKyU8lBFK5JusRDcNNhxHWQ2Y7FYnGXSLQQHNwXAZDJRt149srIysVgsmIMv5DUHm0m/KG910ZGe7iwTZA4mIz3dSSYj3UKQXcZkMlG3bj2ys7I4ezaPeXNnMfKJ0S719qQNntBRHWwAyDyZQcMmZsd1w8ZBZJ7KcJErYd2KRdzQ5TYArFYrX818j/tGji1XPjfzJPUbNnFc12vYmJzMky5yO1cu5ONnR7Dmm8+IHOH6/Uncuo72t/UsU0dO5knqN7qgo36jJmXq2LbiZ94fdz+/ffUp0Q+OccRnZaQxY9LjzP37Mxzd5+qQPYnPVYTKoqo5mw7YnIgDKeUZIAmbYwFACNEI6AbsBWYDzwshNgsh/imEaFsq+zXAz0B/KeU+N9ddc4XM/OQj7h0+gtqlfkVqqg+bVi/jyP5EYgY9AMCqxT9w499ud3JWV8stkf0Y9fY8eg4byaafv3JKSz2YiJ//NTQJbflf6ejaqz9j35vP3fc9yoaf5gNQN7AhT3/wFY//Zwa9HhjFgg/+zbmzef+Vnv8GH58rD5WFt81Gu1MIsQuwAv+RUu4FEEK0AnoBdwPbhRC3SSkTsb1O+x3bq7VxV6IoyGwm7USa4zrdYsFsdv4jCQoyk5Z2AnNwMMXFxeTm5BAY2ACz2Ywl7UJeS5qFILPrH1h10BEU5CyTbkmjSVCQk0yTIDPpaWmYzfbyc3MICAxkb/we1qxcwYfvvkVOTg41avhwzTXXMGTY8OrXTtXABoAGjZtwOuNCj+f0yXQalOollJCwaxuLvpnD5Nc/wc/fH4ADifHs37ubVYt/pKDgLMVFxdSsWYuhD1/oNdRt0Jgzpy/0lHJOn6Reg8Yu5ZfQvlsYv855zykuccvacns1APUaNOZMqd7YmVMZl9TR8baeLJll02Hy88fkZ7OnWSuDBuZmnDqRQrPWotz87qSGF81Hq2o9m7+AW0pHCCHqA8GAxDZmc7OU8hYp5SclMlLKXCnlAinlaGA+0MeeZAXuAboKISZfSUU6dOxEcnISKSnHKCosZPnSJfToGe4kE9YznEULfwJg5Ypf6XprN3x8fOjRM5zlS5dQWFhISsoxkpOT6Njphmqpo12HjhxLPsrx1BSKigpZ+esy7urh/Id+Z4+eLPnlZwBW/7aCLn+7FR8fHz6dM5+fl/3Gz8t+Y9jwB3jwkcdcHE11aafqYANAK6M9acePkZ6WSnFREVvWraBztzudZJIOSua8/yrPvPQmAYENHfGjn/8H7877hXc+X8i9I8fR/e4+To4GoFkrQWZaKlnpJzhfXETilrW07Xybk8zptAsz6A7u3kqD4OaOa2W1krh1He0u4Wyat76eU2mpZNp17N28BnHL7U4yp05c0LF/1xYa2nXkncnCarVtQJtpOc7ptBQamJuWq8vd6J7N1bMK+I8QYoSUcp4Qwhd4C/gQyC8rgxDiDuAvKWWmEMIfaA+sLUmXUp4VQsQAG4QQFinlrIpUxGQy8cKUaYx6bCRW63n6DxhEmzZt+eiD9+jQoSNh4REMGDSYKZMmEhsdSf2AAF5/0zYNsk2btvSK7s2Avn3w9fVl8ovT8PX1rZY6TCYTEyZNYeyoR7FarcT1G0CrNm2ZMf0D2rXvwF1h4fQdMIiXpzzPoLgo6tcP5J+vvVmRW1Dt2snbbQDw9TUxYtRE3nhxLNbzVu7qFUdIi9b8OG8GLY12dO52F9/Mep+Cgnw++PcLADRqEsyzL79VoXtdw9eXyAfH8M3rL6CsVm7oEUWTkOtY/8NcmrY0aHvL7excsZCkvbuo4etLzTr1iH38OUf+5H3x1G/YhAZB5TuAGr6+9HnoKea/+jzKauWmsN4EhV7Hmu/n0KylQHS5nW0rfuZI/B/UMJmoVacu/Uc9D8DRxD2s/X4uNUwmfHx8iHnkaWrVrV8h29yBjxf1bKrc4WlCiFDgI6Ad0AT4Vkr5uBAiDJggpYy9SH4EMAHb2FcNYAnwvJRSCSFypZR1S5W7HhgnpVx0iSqo6rIlvD5i4NLoIwauTIc+YuDS2I8Y8OjTf+ne9Ct+gPfpEFQpHqqq9WyQUh4D+gIIIW4HvhZCdJZSrqVUj6WU/DxgXjlllZ7Bdgz470YMNRqNRnNVVDlnUxop5e9Ai8quh0aj0VRFvGmCQJV2NhqNRqMpn6q62LQstLPRaDQaL0U7G41Go9G4HW+ajaadjUaj0XgpNbzH12hno9FoNN6KN/Vsqtw6myqAbhCNRnO1ePTpv0aeuuLnVU/RSK+z0Wg0Gk3F8aaejXY2ZeCJ1di559zXgap7je0LWB1Wxut2qpiOTQcy3abjjrYNAM/YkZJZ6JbyQxrYNs/s/fFWt5QPsGzUrW4ruzz0mI1Go9Fo3I7u2Wg0Go3G7eh1NhqNRqNxO17ka7Sz0Wg0Gm+lhhd1bbSz0Wg0Gi/Fe1xN1Tups0qxacN6+sZEERsdyayZn7qkFxYWMnH808RGRzJ82BBSUy+clTFr5gxioyPpGxPFpo0bytXx+8YNDIyLpl9ML+bMKlvHpInP0C+mFyPuu4fjdh1bNm9i+NCB3DMwjuFDB7Jt65ZKs0O3U9Vpp/idm3nh8XuY9OhglnzvevLGrz99xZRRw5g2ZjhvTB7DyfQTjrRH+t7OS089wEtPPcD7r0woV4e77di2eSMP3hPHA4P78PW8z1zS9+zaweMj7iHyjptYt3qFs31LFjJicAwjBsfw65KF5dpwS2gAM++9gVn33ciQm8s+aO3O1g2ZMfQGPhnaiefubu2I/0eM4PuHb+Hl3ka55XsMn6sIlYVSqkoGwzCeMQxjr2EYCYZhfG0YRk3DMNYahiENw/jTMIxNhmEIu2ysYRi77PF/GYbxuD3+ZcMwJtg/1zQMY6VhGC9fRrfKL1Iqt6BYhUdEqAOHk9WZvHMqNjZOJSQeUPlFyhHmzpuvJr84VeUXKbVg4WI1Zuw4lV+kVELiARUbG6ey886pA0eSVXhEhMotKFb5RcpBToFVZeUVqZ7hESrx4FF1OqdAxcTGqT/37lc5BVZHmDV3vnphylSVU2BVP/z0i3ryqXEqp8Cqtu9KUIeTT6icAqvaFb9P3dG9uyNPCe6yw93l63a68nbauP+0Wp+Yoe64q6dasD5erd1rUeG9+qhvf9upNu4/7Qgzf1ipVu05rjbuP63+8e5MNfyRUY60Tjfc6CRbEjxpR1LGWdWjZ7jaGn9QHbbkqug+sWrDzr/UsdPnHGF7wmG1duse9eS48Wr+D7844vceSVc9wnqqvUfS1V9Jts9/JaWrY6fPOcqPnr5F9fl4izqela8e+mKXiv1kqzqUkase+/pPFT19iyM8/OUudTA9Vw3+bLuKnr5FDZ2zw5E2aeFf6qUl+9SWI6ed8tjx6HNyy8EsdaXB03UsCVWyZyOEaA6MBbpIKTsCvsAwe/JwKeWNwOfAG0IIP+BTIM4efzMXHbJmPy76R2CnlPLlitQhIX4PoaEtCAkNxc/fn+g+Maxds8pJZs3q1fTtNwCAyF5RbNuyGaUUa9esIrpPDP7+/oSEhBIa2oKE+D0uOvYm7CH02msJCQnFz8+fXtF9XHSsW7uK2L79AYiIjGLbVpuO69u1p0mQGYDWbdpyruAchYWuaxTcbYdup6rTTof3/0VQ0xCCgptj8vPj1rsi2b1lvZNMuxtu4ZqaNQFoJTqSeTLdpZxL4W479v0VT/OQa2nWPBQ/Pz96Rvbm9/VrnGSCmzWndVuBz0XjFTu2bqJz19uoHxBAvfoBdO56G9u3bHKxwQiqy/HsAtJyzlFsVaw7eJpu1zVwkoluF8Qvey3kFtpOo83Ov7DIaHfqGc4Wue+U2upKlXQ2dkxALSGECagNHL8ofT3QBqhnlz0FIKU8J6WUF5XzLXBASjmposrTLRaCmwY7roPMZiwWi7NMuoXgYFsX3GQyUbdePbKyMrFYLJiDL+Q1B5tJvyhviQ6z+UIX3mwOJiPdWS7Dku6QMZlM1K1bj6ysLCeZVSt/5fp27fH39/e4Hbqdqk47ZZ3KoGGTIMd1g8ZBZJ7KcJErYcOKX+h0y22O66LCQv7+9EP8c/wj/LF5XZl53G3HyYx0mgRdkGkSZOZkhqutZXEyI50gl7yuzrRxHX8y8i784DiZV0ijOn5OMs0Da9I8oCZv9m/POwM7cEtoQIXq4Gl8fK48VBZV0tlIKVOBN4Fk4ASQLaVccZFYHBAvpTwNLAKOCiG+FkIMF0KUtus5oFBK+bQn6u5pDh08wPvvvsXkaX+v7KpUaXQ7ObN5zTKSDiYSPeh+R9wbs3/ipXfn8tjEV/h65jukn0i5RAnVG18fH5oH1OT5RYn8Z+VBxoW1pI6/b2VXywVvGrKpks5GCNEA6Ae0BJoBdYQQJX8VXwohdgN3ABMApJQjgQhgmz1udqniNgK3CyGuaDQvyGwm7USa49r269rsLBNkJi3NNsBaXFxMbk4OgYENMJvNWNIu5LWkWQi6KG+JDovlwgCtxZLmeOVTQhNzkEOmuLiY3NwcAgMD7eWmMeGZMbzyr9cIDb22UuzQ7VR12imwURNOl/oln3kynQaNmrjI7d29jcXfzmXs1Dfw87vQy2vQ2NYrCgpuzvWdOpN8aL9LXnfb0bhJEBnpF2Qy0i00buJqa1k0bhJEukveIBe5k3mFNKlzwe7Gdfw5lVfkIrMlKZPzVoUl5xypWQU0D6hZoXp4FC/yNlXS2QB3A0eklBlSyiJgAXC7PW24lPImKWV/KeWxkgxSyngp5TtAJDCoVFnrgaeBZUKIsqedlEGHjp1ITk4iJeUYRYWFLF+6hB49w51kwnqGs2jhTwCsXPErXW/tho+PDz16hrN86RIKCwtJSTlGcnISHTvd4KKjfYdOHDt6lNSUFIqKClmxfCk9wpx19AgLZ/GinwHba6C/dbXpyDlzhnFjHuepceO56ebOlWaHbqeq004tjXZYjh8jI+04xUVFbF2/kptuvdNJ5ughybwPX2Ps1DeoH9jQEZ+Xe4aiIturpZzsLA78tYem17b0eDtd364jqceOcuJ4CkVFRaxZuYzb7wxzqUdZdLn1DnZu3UzOmWxyzmSzc+tmutx6h4vc/vRcmgXWxFzvGkw1fOjRpiFbkpz3ltt8JJMbmtcHoH5NE80Da3LizLkK1cOT+FzFv8qiqq6zSQa6CSFqA/nYei07gPYXCwoh6mKbSLDWHnUTcLS0jJTyRyFEELBcCNFDSpnFZTCZTLwwZRqjHhuJ1Xqe/gMG0aZNWz764D06dOhIWHgEAwYNZsqkicRGR1I/IIDX33wHgDZt2tIrujcD+vbB19eXyS9Ow9fXtQtuMpl4bvJUxox6hPPnrfTrP4jWbdry8Ufv0759R3r0DKffgMFMnfwc/WJ6ERAQwL9ffxuAb7/5kmPJycycMZ2ZM6YD8NEns2jYqJFH7dDtVHXaydfXxP1PTODtaeOwWq10j4yleYtW/DT/U65rez0333oX383+gHMFZ5n+nykANGpiZuy0NzlxLInPP3wNHx8flFL0GTKC5mU4G3fb4Wsy8dSEyTw/7gms1vP0jh3Ada3aMOfTDxHXd+D2u3qy768EXnp+HLk5OWzeuI7PZ05n9tc/Uz8ggPsffpzRD98LwAOPPE79ANexFquCjzck8c9Yga+PDyv2ZZCcmc8Df2vO/ow8tiZlsfNYNp1DA5gx9AbOK8WszcnknLNNEnijfztCA2tR08+XLx64mXfWHuaPY9kuejyBF63prLrn2Qgh/g4MBYqBXcBI4FdggpRyRym5etgmALTG5pjygHFSyh1CiJeBXCnlm3bZl4FwoJeUsqAc1UrvZnxp9K7PFUPv+lxxqtGuzx59/P+RdOaK/0A6X1e/UlxUlXU2lYh2NpdBO5uKoZ1NxdHO5ur44+hVOJsWl3c2Qoho4D1sy04+k1L+56L0Z7F1AIqBDOBhKeVRl4JKUVXHbDQajUZzGdwxZiOE8AU+AnpjG7q4Vwhx8RDGLmzDFzcAPwCvX67cqjpmo9FoNJrL4KYxm67AQSnlYQAhxDfYZgf/VSIgpSy90nYLcD+XQTsbjUaj8VKuxtcIIR4DHisV9amUsvQmd82BY6WuU4BLHUP6CLDscnq1s9FoNBpv5Sq8jd2xuO6gehXY1z92AXpcTlY7G41Go/FS3LRuJhUILXUdYo9zQghxNzAF6CGlvOwiJO1sNBqNxktx05jNdqCtEKIlNiczDLivtIAQ4mZgBhAtpazQbq566rMrukE0Gs3V4tGpzwkpuVf8vOoYUrciU5/7AO9im/o8W0r5LyHEK8AOKeUiIcRvQCdse1cCJEsp+16qTO1sXNENotForhbPOpvUq3A2zS/vbNyBfo1WBp5YvObNOqqDDZ7QUR1sKK3jUHq+23S0DqoFuP9e1Bkyxz0KgLzv/89tZZdHZe51dqXoRZ0ajUajcTu6Z6PRaDReijdtxKmdjUaj0XgpXuRrtLPRaDQar8WLvI12NhqNRuOleNMEAe1sNBqNxkvxpjEbPRvtEmzasJ6+MVHERkcya6brVkKFhYVMHP80sdGRDB82hNTUFEfarJkziI2OpG9MFJs2bqjWOqqDDZ7QUR1sANixdROP3tePR4bF8d382S7p8bt38tTDw4gNu4WNa1a6pJ/Ny+WBgb2Y/s6rlWZH5E3N2fXeQPZ8MIjx/Tu5pIc0rsPSl6L5/fW+bH2zH1E3hzjSOl7bgNX/imH72/3Z9lZ/rvFzPTXVU/hcRag0lFIeC4ZhhBiGsdAwjAOGYRw2DONDwzCuKZX+rmEYqYZh1CgV95BhGMowjLtLxfW3xw22X48xDOOgPa7xRTrDDMPYbRjGXsMw1lWgniq/SKncgmIVHhGhDhxOVmfyzqnY2DiVkHhA5RcpR5g7b76a/OJUlV+k1IKFi9WYseNUfpFSCYkHVGxsnMrOO6cOHElW4RERKregWOUXKQferKM62KDb6cp1HLScVfJ4jrorLFxt2LVfJaZkq6jesWr1lnh10HLWETbtPqBWbtqtnnjqWTX3m4VOaQctZ9WEyS+pR0ePVc9OmuqI89S9qD14tqp7zxx16ES2aj/6OxUwbK7ac+SU6vz0j6r24NmOMGvlPjX2002q9uDZqvPTP6okyxlVe/BsVe+eOSo+6ZS6dfxPqvbg2SrkoS9V3XvmqNqDZ5eo8OgzVablqSsNnq5jSfBYz0YI4QMsAH6WUrYF2gK1sB+6I4SoAQzAtrX1xTuIxmPbn6eEe4E/S11vAu4GnE6KE0IEAtOBvlLKDsCQitY3IX4PoaEtCAkNxc/fn+g+Maxds8pJZs3q1fTtNwCAyF5RbNuyGaUUa9esIrpPDP7+/oSEhBIa2oKE+D3VUkd1sEG3U8V17E9MoFnzUJo2C8HPz4+7IqLYvHGtk4y5aXNatjGoUcY7ngPyL7JOn6bz325zSfOUHV3aNOZwWg5J6bkUFVv5YdNhYrtc6ySjFNSvZTvds35tf05k2ha03n1jcxKOZhJ/1HYy6uncc1itlbfpiDsOT3MXnnyNFg4USCnnAEgpzwPPACOEEHWBMGAv8DE2Z1KaDUBXIYSfXbYNsLskUUq5S0qZVIbO+4AFUspku1yFNowDSLdYCG4a7LgOMpuxWCzOMukWgoObAmAymahbrx5ZWZlYLBbMwRfymoPNpF+Ut7roqA426HaquI5TGek0Drog17iJmVMnK/ZnZbVa+ezDtxj55LOXlHO3Hc0a1iblVJ7jOvX0WZo2quMk8+/vdjHsrtbs/+QeFrwQyfjZWwBo07Q+CsXCKb3Y9FpfnunbsUK2uwsfnysPlYUnnU0HYGfpCCnlGSAJm/O4F/ga+AmIEUL4lRJVwG9AFLYT4xZVUKcBNBBCrBVC7BRCjPivLNBoNFfNkp++o0u37jQOMld2VS7LkO6tmL/mAMYT3zHw1ZV89tRd+PiAybcGt11v5uH313H31CXE3dqCsI5NK62e3jRmU1UmCPgDfbC9YjsDbMXmWErzDbZXacOwOaWKYAJuAWLs5U0VQhgVyRhkNpN2Is1xnW6xYDY7/5EEBZlJS7NtelpcXExuTg6BgQ0wm81Y0i7ktaRZCDK7/oFVBx3VwQbdThXX0ahJECfTL8idzLDQqHGQi1xZJO79k8ULvuWhIb2ZNf0dVi1fzJxP3vO4HcdPnyWkVE+mecPanCjV0wEYEd6WHzcnAbBtfwY1/XxpXK8mqafy2PSXhVM558gvPM+vf6RwU6tGFbLfLXiRt/Gks/kL24PfgRCiPhAMmIFAIF4IkQR056JXaVLKbdi2tG4spdxfQZ0pwK9Syjwp5UlgPXBjRTJ26NiJ5OQkUlKOUVRYyPKlS+jRM9xJJqxnOIsW/gTAyhW/0vXWbvj4+NCjZzjLly6hsLCQlJRjJCcn0bHTDdVSR3WwQbdTxXUY13fgeEoyacdTKSoqYv2qX+nW/bKHNALw3LRX+fzH5cz9fhmPjH6GiOhY/u+JcR63Y+fBk7RuWp8WQXXxM9Vg8B2tWLLjmJNMysk8enay9VhE8wBq+vmScaaA3/5MpcO1Dajl74tvDR/ubB9MYkpWhex3B940ZuPJdTargP8IIUZIKecJIXyBt4APsTmWkVLKrwGEEHWAI0KI2heVMQkouAKdC4EPhRAmbL2nW4F3KpLRZDLxwpRpjHpsJFbrefoPGESbNm356IP36NChI2HhEQwYNJgpkyYSGx1J/YAAXn/TVnSbNm3pFd2bAX374Ovry+QXp+Hr6zo9sjroqA426HaquA5fk4lRz0zixfGjsFqt9IrpR4uWbfjis+m0vb493bqHsT8xgX9MeZbcnDNs/X0982d/zCdfLHApqzzcbcd5q2L8rC0snNIL3xo+zFtzgMSULF4cejN/HDrJ0h3HeGHeNj58/A7GxHRAoXj8I9sU6qy8Qj5YnMD6/8SBgl93pfDrHykuNngKb1pn49HzbIQQocBHQDugCfAttkkCKcB19ldoJbIL7Om1gC5SyjEXlTUXWCyl/EEIMRZ4DlsvKR1YKqUcaZebCPwfYAU+k1K+e5lqquqyJbzeOr9ydVQHG0rr0EcMXBr7EQMeffwnnSy44gf4dY1rVoqLqrTD04QQt2MbexkgpfyjUipRNtrZVHL51UVHdbChtA7tbC5NpTibU1fhbBpVjrOptO1qpJS/Ay0qS79Go9F4O960N1pVmY2m0Wg0mmqM3ohTo9FovBRvmiCgnY1Go9F4KV7ka7Sz0Wg0Gm9F92w0Go1G4wG8x9tU2tTnKoxuEI1Gc7V49OmfmlV4xc+r5oH+/39NfdZoNBrNf4f39Gu0symT6rIITy9WrFwdnrQhK/+823QE1rJt9/JLvOuRA/8r4jrZNsvsN3OHW8pf+GgXAE7muu9mNK7r+cepHrPRaDQajdvxpkWd2tloNBqNt+I9vkY7G41Go/FWvMjXaGej0Wg03ooes9FoNBqN29FjNhqNRqNxP97ja/Suz5di04b19I2JIjY6klkzP3VJLywsZOL4p4mNjmT4sCGkpl44sW/WzBnERkfSNyaKTRs3VGsd1cEGT+jwhA2bN21gSL8+DIqL4vPZM8vUMeW5ZxkUF8XD9w/leGqqU3raieOE3XYL8z+fXa6Ofbu28trY4bw65l5W/zTfJf33Xxfy5rMP8vaEh/nwxSdJO5YEQF5ONh+/NI7J90ex4LPyD8y9OaQ+04d05JN7OjLoxmCX9PC2jZh3/428M7A97wxsT6Ro7Egb0bU57w/qwPuDOtC9VYNydWz5fQPDBsZwT79ovphTdjtNnTSee/pF8+iIYZw4fqGdDh6QPPbQfQwf0pcH7unPuXPnytXjbnyuIlQaSimPBcMwQgzDWGgYxgHDMA4bhvGhYRjXlEp/1zCMVMMwapSKe8gwDGUYxt2l4vrb4wbbr30Mw/iXYRj7DcNINAxj7EV6/2YYRnGJ/GWCyi9SKregWIVHRKgDh5PVmbxzKjY2TiUkHlAj236DAAAfq0lEQVT5RcoR5s6brya/OFXlFym1YOFiNWbsOJVfpFRC4gEVGxunsvPOqQNHklV4RITKLShW+UXKgTfrqA42VLd2yjxbrE7mnFM9wyNUwv4jKj37rOoTG6d2xu9TmWeLHWHmnC/U85NfVJlni9W3Cxap0WPGOqU/PnqMemL0GPXBx5864kpYtCdN/bwrVd12Z5ias/IPtWDnMdUjsrf6dMkWtWhPmiN8t+WQ4/Ors35QcffcrxbtSVPfbzui3vt2hZr0xgz10NjnnfKU0H/mdnU8O189+vWfauBnO9Thk3nqye/iVd9PtzvCu2sOq8UJFqe4vp9uV39ftl/tOpat+s/crobM3qn2p+eqoXN2qr6fbneUn5FTpNKyClRYzwi1O/GwOn46T/WJiVXb/kxUGTlFjjBj1jw18YUXVUZOkfr6h4XqiSfHqoycInUiM1/17hOrft8ZrzJyitTBYxkqLatAZeQ4boZHn6knc4vUlQZP17EkeKxnI4TwARYAP0sp2wJtsR35/Lo9vQYwADgG9LgoezwwrNT1vcCfpa4fAkKB66WU7YBvSun1BV4DVlxJfRPi9xAa2oKQ0FD8/P2J7hPD2jWrnGTWrF5N334DAIjsFcW2LZtRSrF2zSqi+8Tg7+9PSEgooaEtSIjfUy11VAcbqks7/ZUQT0jotTQPCcXPz5/IqN6sX7vaSWb92tXExPUHIPzuXmzftgVl37Jq3erfaNasOa1at3Epu4Tkg4k0Cm5OI3MzTH5+3HRHBHu3b3SSqVm7juNz4bkCSn5PX1OzFi3b3YCfv3+55bdtUoe0M+ew5BRSbFVsOHSari0Cy5UvzbUNarI3LQergnPFVpJOn6VzaICLXOLeeEJCQx3tFNGrDxvWrnGS2bBuNX1i+wEQFtGLnfZ22rbld1q3NWhrXA9AQGAgvr6+FaqfO/C5in+VhSdfo4UDBVLKOQBSyvPAM8AIIURdIAzYC3yMzZmUZgPQVQjhZ5dtA+wulT4KeEVKabWXnV4q7SngR6B03GVJt1gIbnqhCx9kNmOxOK+gTk+3EBzcFACTyUTdevXIysrEYrFgDr6Q1xxsJt3iuvq6OuioDjZUm3ZKd5YLMgeTke78tc9ItxBklzGZTNStW4/srCzOns1j3txZjHxitEu5pck+fZLAxkGO68BGTcg+neEit2nZAl59chiLv/iY/o+MvWSZpWlUx5+TuYWO61N5hTSq4+qcbmsZyHsD2/N8RCsa1/ED4MipfDqHBODvW4N615jo1LQ+jcvIm5FuIcjc1HEdZDaTkeHcnhkZ6QSZL7RTHXs7HUtOwsfHh2eefJT/u28wX34+q8K2uQMfnysPlYUnJwh0AHaWjpBSnhFCJGFzHvcCXwMLgX8LIfyklEV2UQX8BkQBAcAioGWpoloDQ4UQA4D/196Zx0lVHXv8O4CGRRYXGBM1bpBCwBXFBVDABIWnLBoDaKJR1KfvqVGfJhrUGM3iS1yjqMGYRNSIwhNcURE1LnE3RNx+YlwAlUUUWRRhZnh/1GmmaWZGmj7dzHK+n898PrfvvV3Vfe/0rVNV51QtBM6QNMvMtsG9pf7APkX6XolEg+emG8cy6phjaZ3llRRC70FH0HvQEbzy1DQenTSeUaePiSIX4MXZi3ny359SUbWaQ7puxU/67ciFD7zNjA+X0KVjG/53aFeWfFmBFiyjKnKh4cqKSl6d8Qp/Gn8nLVu25IxTR2O7dGfvXvtF1dMYqS8TBDYFBuMhtiXA87hhyWYCHkobiRulbL6Be017AzcBmezm1cDPMh5PPnQqL2fex/PWvF4wfz7l5eVrn9OpnHnzPgagoqKCZUuX0qHD5pSXlzN/XvV758+bT6ec9zYWHY3hOzSa69Rp7fMWzJ9Hx06d1jqnY6dyFoRzKioqWLZsKe07dOD1ma9y3dVXMGzQd5lw+63ccvM4Jk64fR0d7bfYisWfVHtLixctpP0WHdc5L0NNYba6WLR8JVttVu2NbNlmUxYtX7nWOUu/qqSiyo3INH3Czlu1XnNs4oyPOevuN/jF1LcB+OjzdZP3HTuVs2D+x2teL5g/n44d176eHTt2YsH86uu0PFynTuXl7L5nTzpsvjktW7Vi/9590VtvrPf3a8qU0ti8AfTM3mFm7YCtgXKgAzAzeDp9yAmlSXoB2BXYStLbObLn4vkggMnAbmF7b2BCkPl94HozG7Y+H7Z7j12ZPft95s6dw6qVK3nowQc4qP+Atc7p138A994zGYBpjzxMr333o6ysjIP6D+ChBx9g5cqVzJ07h9mz36fHrrs1Sh2N4Ts0luu0S/cezJn9AR99OJdVq1Yy7eGpHHhQ/7XO6XtQfx64bwoAjz36CHvvsy9lZWWM+8ttTJn6KFOmPsrIY37EcaNP5qiRx6yjY7vOXfnk47ksmv8RFatWMeOZ6XTfp/da5yz8eM6a7TdfeZattt52HTm1MWvhcr7ZriWd2m5Ki2Zl9N15C16YvXitczZvtcma7V7bd2DuZysAaFYGbb/h+ZPtt2jFDlu05p9zP19HR9duPZg7Z/aa6zT9kQfpk3Od+hzUnwfvvweAJ6Y/Qs9wnXrt35t335nFii+/pKKighmvvMSOO+683t8vNimMVjPTgcvM7FhJ40Pi/grgOtywnCjpDgAzawO8Z2atc2ScB6yoQfYUPFT2Hj654G0ASWtCbWb2V+B+SVPW58O2aNGC88dcxKknn0hVVSXDhh9J585dGHvtNXTv3oN+Aw5m+JHfZ8x553LYod+jXfv2/O5yn87ZuXMXBh46iOFDBtO8eXN+fsFFNSYRG4OOxvAdGtN1Oue8MZxx6klUVVVx+NDh7NS5C3+8/lp26dadA/sNYMjwI7l4zM848vBDaNeuA7/638vXkVMXzZu3YPiJZ3LTr85hdVUV+wwYzNbb7chDE25mu52N7vv04ZmpdzPr1Zdp3qIFrdq0ZeTpP1/z/l+f+gNWfLmcyooKXn/haU668Aq23m6HNcerVsO4f8zm4kHfoVkZTNci5ny2gqN7fot3Fi7nhdmfc1iPTvTavgOVVatZ9lUF1/z9ff9szcr47eGeuP9iZSVXPf4uVTVE0Vq0aMFZPx3D2aedTGVlFYcNHc5OO3fmphuupWu37vQ9aACHDT2SSy88jx8MPZR27dvzy9/4dWrXrj0jf3gco48dQVlZGfv37ssBfXPnM5WOhrSos6TN08xsO2AssAvQEbgTnyQwF9ghhNAy594djrcC9pZ0Wo6sv+LGY5KZdQBuB74NLANOkfSv2s7/mo+5uiGXtS+FjsbwHUqhI7UYWH8aUYuBkj79l6yoyZzWTbuWzTaKhdponTrN7AA89zJc0isb5UPUTDI2G1l+Y9GRjM36k4zNhrF0A4xN241kbDZauRpJ/wC231j6E4lEosHTcKJoqTZaIpFINFQaUs4mGZtEIpFooKQWA4lEIpEoOsWyNWZ2KHAN0Bz4k6TLco5/AxiPL2dZBIyQ9H5dMuvLos5EIpFI5EsRyj6HZSljgUFAN2CUmXXLOW008JmkzsBVeP3JOknGJpFIJBooRSrE2Qt4R9K7klbi1VuG5pwzFLglbE8CDg7FlmslhdFqoGUJrkpj0NEYvkMpdJTiO2SmJxeTzPTkYpKZolwswvTkRkORcjbb4NX3M8wF9q3tHEkVZvY5sCXwSW1CG9eVj0MDSrklEommTMsW+T+vzOxk4OSsXeMkrdvNLzLJ2CQSiUQTIhiWuozLh3h/sAzbhn01nTPXzFrg1fgX1aU3GZtEIpFIZPMi0MXMdsSNykjg6Jxz7gWOA57Fixw/JqnOagZpgkAikUgk1iCpAjgNeBh4E7hL0utmdomZDQmn3QxsaWbvAGfjRZLrZKPVRkskEolE0yF5NolEIpEoOsnYJBKJRKLoJGOTSCQSiaKTjE0iOmbWvo5jUVbtmdkmdRzbsbZjTY3QsLC2Y4eVQP+mxdaRaBikqc95YGZ71XU8dhO40Ba7G/CBpIWRZLYERgCfAfcBPwX6Av8GLpVU6wrgPHjUzAZK+ixH90B8FkutD8A8uMfMhoVyGtk6dgfuAXaIoGMdzGyvmPfZzHbP7SqbdexUSTcUqGKamR2aWyTRzE4AxgD3FygfM7tI0iU17G+P34t+herIkdsZ2B14U9IbMWXn6Bki6d5iyW9qJGOTHy8Br1FdkiF79e5qYEAhwsO0wj8AnwIX4MXw5gM7mNnPJN1S1/vXk/HAKqAN8D/497kO6AP8FYgx2h0HPG5m38sYSTM7Gvg18B8R5AO8Akw1s8MlfRF09ANuBU6IoaCGwUUZbuQOB8oiGZ3JZnaUpJdzdP8SOBwo1NicDTxiZv8haVaQfT6+buKgAmVn6GNmv5Y0JrPDzMrxqbN3FyrczB4HjpL0iZn9CLgQeBK42MzGSbo2go4jcnaVAWPDgkUkFfw9mjrJ2OTH2fgCpi/x4nSTJS2LKP9SYCC+GvdxYDdJ75pZJ2A61YXvCqGbpB7hRzRXUuaB85CZ1TjCzhdJN5nZCuCx4M2MAE4B+n9dGfI8dFxgZhcAD5vZIPy6XY23GY/VW/gl4Dngq6x9WwJXEmFwETgKmGhmx0h6NhQzvAEwIngEkh40s69wwzwMOBEvtHhgrudZAEOASWZ2paSzzawLMBW4XNKNEeR3zPK4zwD2l7QoeP7PAQUbG+BO3DguoHoQ2QY3+KuJYDSbOilnkweSrpbUBzgdDwVNN7O7zGyPSCqqJL0t6UXgPUnvBr0LgFjN01cGmRXARznHojWyl3QrcAnwT3wU3SeWocnS8StgMvAycBkwIKKhATcEq4DfSeovqT8wL2zHMDQEj2YYcFvoITIJ6AgcKmlJJB3TgeOBJ4Cd8OsUy9AgaQUwHPfA7wAeBc6NZGgAVpnZNmF7GbA8bH+F91uJwQFAK+BFScdLOh74JGxH8ZSbOmlR5wZiZt3xMg4/An4q6a4IMv+Fj2abAY+F7cwo63FJu0fQsQD3yspwj2NCOFQG/EBSwaV9zWwmPhosA7YHFuIPiDJgtaTdIui4L0tHb+AdYF7muKQhtbw1Xz2b4R7ntnjY8QlJO8WQHeRvETa7AVPwB/VpQBWApE8LlL+U6uv0Ddx4VlJ9L9oVIj/oODtsboLnAJ/Cw1wASLqyQPn98JDy/wFbAHvhXkgf4GFJlxciP0tPM3wgOQz4GTAh5r1u6qQwWh6Y2U64gRmKl9eeAPxG0peRVLTHR+kZA5OdE4g1Kjg3azvXC4jlFRR9lhNweS3bUQlh0rNC/uYWoG1kFS9TfW+X4qXcXyAYA9wT2WAkxf68NZGt4w817CsISU+Y2QG4h9wWv2YrgNMlvRVRTxVwjZlNwhuCJSKSPJs8MLMq4FV8hs0ScgxAoSO4jYWZbQ4s/rpCegXI3xI4EJidmwiPqGMToAfwYQg7FkNHGdA2VnirFIS8xipJq8JrAwYD70uavFE/XKJJkYxNHpjZxdThYUj6ZYHyt8cf+p+H1/1xl/59YGzuNN8N1HERXljvrdBHfCqwB54TOlrSoxF03A+cJ+k1M/sm7qG9BOyM9864OoKOG4FrQ4HA9nj12Uo8zHKOpDsi6PhDXcclnRFBR1HvuZk9CYyWNCtMGX4BuB0P270o6WsLKK6HjpPw8OKsYJBvBo4EPgCOk/TPQnXUoXucpJO//syvlXMaHjb7JFynPwO7Am8DJ0qaWaiOpk4Ko+WBpIuLrOIuPNH6eZh0MBH4LW4MrsdnEhXKCDwHAV4ivAxPSH8HDxMVbGyAHSW9FraPB6ZJOtbM2gLP4LPGCqWvpFOydLwtaZiZbY0b0IKNDT6D7jX8vnxEcRrrFfueb56Z8ozf7zsknR4WW77MelTrXQ9+gk+bBxiFr4HZCdgTD6v1LUR4Vl4rlzLcS4vBqZKuC9vXAFdJmhzyRTfiecFEAaTZaHlgZo9kbZ9fBBWtJGVmiP0Q+LOkK/CHaa9IOlZmhcsOwUdzlZLeJN7gY1XW9sHAgwCSlhIS3xHIHvF/D0+uI2lezadvEN/E1wwdgk8E2QS4R9ItkdY8QfHvebYnPgCYBhA8plj3oiITpsPzdeMlLQpecpsI8hfinvHLWX8vhb9OEeTD2v/7nTIhRklPED9P1yRJnk1+dMzaPgofgcYke+Q8ADgfPHHpofYofGVmPfDFov2Bc7KOtY6kY46ZnY73Lt8LeAjAzFrhD+wYLA7lVj7ER52jg44W+BTWgpG0CB/V3mhm2+KTQ94IC2xvjaGD4t/zV83sctwz6ww8AmBmHWIID1SFcOln+ODi11nHYtyLd4GDJc3OPWBmcyLIB18n9Fd8uv5kMzsTn1Y/AFhHbyJ/krHJj2InuB4zs7uAj4HN8enPhB9ywfmawJlUr+W4StJ7QcdgfE1MDEbjP9rvAiMkLQ779wP+EknHf+Ihmq2BM7M8moOBByLpANZUEhiFe1BT8ZF1LIp9z0/Cw1zfBgZmqi3gOZtYs/guwr2M5sC9kl4HMLODcENRKFfj16amh/7vIshH0hgzOx4Pv+6MTxM/GfeYj4mho6mTJgjkgZktxtcPlOFx6Cezjxe6tiMkV0fg4Zu7JH0Y9u+Ju/YPFyK/VJhZi7BotEFjZpfg5XXexKe5PxT7e5XinodcUGfg9RAujU7wKNtmLxY1szZ4WZ+YVTYSDZRkbPIgjNRqRdLfI+npAHQJL9/OzFSKJPtw4FVJH4TXF1E9c+gnGU+nQB2vSNorbF8r6fRCZdag4xFJA8P2+ZJihzQzU93fAzLeQObHEm1xatAzDDcGM2MPKML9PQafEbgv8FtJN0XW0QX4PeE74LMBP4woP7du2VooQt2yUuho6qQwWh7EMia1EaYi/xFfNPo+YQW+mU0GTokx9RmPp+8X9B2GJ6VH4TOHbsST4YWSnYco1iyeYufPAIreqsDMbsBDWv8ALjWzXpIu/Zq35cMIYE9JX4T1Tg8BUY0NPk14PO7pD8FrldX58M6TScCM8AfrFsCNYQhKoaNJk4xNHoQR3M/xROiV+I82U55/dIS6XGPwBPq3w8wtwnThsXil2wsLlA8+Is+M1I8Abg4LLV82s/+KIB+Kn9sqiY6M95eLmfXBDfR/R1DTF9hdUmVYgPkU1VPTY/BV5n7Li1cWYwZq2yxv6fdmFrXVBv5/OhLYDV9QfYekdxqgjiZNCqPlgZk9jY/g2gFn4cn2+/AHxq8k7Vug/NeAXlnGILN/M+A5ST0KkR9kvYoXHfwCDxEdmTGSZvaGpG4RdHyB1yorw5OtmR9tzNpoteXPMjqi1EbL0rcnXi7lKPy63a04pe3XhBxreh1BfuY6ZTiQ6usW5TqZ2Vu48c14A7eTlVRXpP4/IQc0FPfWtgTGxI42lEJHUyV5NvmxmaRxAGZ2iqSJYf80M/t9BPlVuYYGvD6XmcUaFVyNhwqW4M2nMoZmT3xGVAx2iSSnLoZmbWdmVWXnVArGzL6DP0RH4T2M7sQT3v1jyA90DQMACMY5vI5lmDPXqQ2eB3wUEF5bLBbzgCuovu7z8HuSqe8WpUI2/pk/x/93twdaRpJbah1NkmRs8iN7EVxufawYC+RWhzplNT0soyzAk/RnM3sYXwyX3b9mHr6QMIaOD4qZ9A50ALaVNBbAzF7A8zir8Yq9MXgLD2sdlgmpmNlZkWRnKLZhfhafHnwsngcEKMdL/VxmZntImlHbm9eTQ/AQ1IeSHjWzY3Dv+Q18UWxBmNmAIL8XbiyviRCyLrmOpk4Ko+XB14SHdpJU0GppM3sfNyo1GZvVKlK5czO7OGYpHjO7HuiOJ70PBu6LnPTGzJ4BRkqaE17PCLraAH+RdHAEHcPwB1BvPLE+AfiTpKJOHDCzrYBFilAYNdR3aw2clZUHbId7HpV435yCvo+Z3Y4PXFsDi/F7MBm/H0j6cYHyMwVwn8YHE7kFcGPUqCu6jqZO8mzyYwxe2+tT1i7JEgVJO8SWuZ4MAS6OKO9Aipv0Btg0Y2gCT4cV/4tC3L1gJE0BpmTF8c8EOoUZZJMlPVKngPXAzPbDG799il+jW4GtgGZmdqykhwpUMRjokm24JC0xs1Px0OCgAuUD7Cppt7DW5kPgW+He38ba3vOGEsXjrgc6mjTJ2OTHNnjOoyu+nuAZfPT+DxXY5Ko2YnsdtRC7wORKSZUAYcptMQpYbp79QtJpWS87EhFJy4G/AX8LYc6j8FBdwcYGuA6f4dgerx4wSNJzZtYVX81eqLGpqslDCsZgoaTnCpQPbhg3xT2a1vh3+RRfhV9weaLa6tCZWUu8bXPBlEJHUycZmzyQdA5A+GHtjceljwfGmdniGDO5aiC211ETPSPLqy3pDUCkxZDPm9lJuQsUzew/8TL6BRMeNKdQvVjx5rBCfhwRchGBFhkPycwuyTz85S0gYsh/I3hI47N3mtkP8coIMbgZz281x73/iWb2Lr6ea0Jdb8wXM2uO54hGAQNxr3linW+qhzqaIsnYbBit8OnP7cPfR/jDqBhE9Qqslh4tmQdbpNj07ngSOrdI4nZktW4ukLPwENfRVHc07YmPpodF0nELHi59Cg83dcPrjMUke+JHbsfXGAnV/wbuNrMTqK7ptjf+Pzw8gnwkXWVmd4btj8xsPF4X7yZJsQz/QfjU88H4YKI33spindmb9VlHUyZNEMgDMxuHJ76XAs8Dz+HrXz6r842F6Wwmb1cbS95K6ujRUls4IU8d9wPnK6fhlJntirfRjhaWCLOIuoeXr0t6LKLsmZJ2DdstgBdiroEJciuB5fh9aEV1aZwyoKWkKFWyc67TG5Kmx5BbCsxsLl6E8wZgiqSlZvZezIkapdDR1EmeTX58Gx85z8IToXPx2TdRKJHX8U085zAC7855JzBJ1ZWZY1Cea2gAJM00sx0i6iEYl2gGJoc1k0AkVUQKa62FpObRhdasp5jXqdhMwr3VEUClmd1D/AoSpdDRpEmeTZ6EZHd3PF9zAN73/lPgWUm/KFB20b2OHH2ZHi1nA9F6tJjZLEldajn2jqTOMfQUmyyvA9b2PDILLtttrM/W1Ai/u354HmUwvs5qNPCAIlWVLoWOpkzybPIkzOx5LZQB+Tz8HYYvBivI2FAarwMoeo+Wl2pJ3p8YWU9RKZXXkfh6JK02s+eBRXhNwnL8/3csPlW8QehoyiTPJg/M7AyqPZpVhGnP4W9m5NxKsbyOUvRoKccX9a1k7aT0psBwxW3dnGjkmNkmeAuDY/G6dGW4IbgOX4pghVZBKIWOpk7ybPJjB3wK5FmSYtURW4ciex0X4D+m3cPfb0Iuogxfk7F7oQokzQcOMLP+eJgRPBTRUHMGiY3LFfj6ne1rqIJwJXAohbeDKIWOJk3ybOoRJfI6tq9hdxk+Lfl8SYNj6kskCsXM3iGnCkLY35xQBaHQxaml0NHUScamHmF1d4aM4nXk6Mstm/9/kq6LqSORKBQze1vSd/I9Vt90NHVSGK1+UZObvsbriKGgRGXzE4mYlKIKQil0NGmSsalHKKszZE1eRyQ1pSibn0jEpOhVEEqko0mTwmj1iFq8jnMk1ZRn2VAdG6VsfiJRKKWogtCQKy3Ud5KxqUeEnM1TwOgsr+PdYvSxySqbPwrvpDieSGXzE4lEIpcURqtfHIF7HY+bWcbrKEZ5/mKXzU8kEom1SJ5NPSR5HYlEorGRjE09J8vrGBGj1XEikUhsDJKxSSQSiUTRabaxP0AikUgkGj/J2CQSiUSi6CRjk6iXmFmlmc0ws9fMbKKZtS5AVr/QPRQzG2Jm59Vxbgcz+68N0HGxmZ2zvvvrkJNX35R85ScSG4tkbBL1lS8l7SGpB96q4JTsg2ZWZmZ5//9KulfSZXWc0gHI29gkEom6SetsEg2Bp4DdQkvph4HngZ7AYPP+CL/E23X/Gzhe0jIzOxTvQ/IF8HRGkJn9GNhb0mmh786NQGbR7KnAGcDOZjYDmCbpXDM7F/hB0DE505HVzMYAxwELgDnk0QrCzKbgNe9aAtdIGpd17CpgIDAPGClpoZntjDfx6hi+00mS3lpffYnExiZ5Nol6jZm1AAYBM8OuLsD1krrjLZsvAL4raS/gJeBsM2uJd1o8HDdKW9ci/g/A30M17b2A14HzgH8Hr+pcMxsYdPYC9gB6mtmBZtYTX4C7B95CeJ88v9oJknri9bfOMLMtw/42wEvh+/2d6u6v44DTw3vOAa7PU18isVFJnk2ivtIqeBfgns3NwLeAD7L6iuwHdAOeCQ3gNgWeBboC70maBWBmtwEn16BjAN6ZEUmVwOdhXVM2A8PfP8PrzXDj0xb3cr4IOu7N8/udYWaZAo/bBZmLgCq8Jh7AbXhxyM3w7rATw/cE97ISiQZDMjaJ+sqXkvbI3hEetMuzdpXhoa5ROeet9b4CKQN+K+mPOTrO3FCBZtYP+C6wv6QvzOwJPJxWE6vxCMTi3OuRSDQkUhgt0ZB5DuhtZp3By/yEytlvATuEPAd42Z+amI7naTCz5mbWHliKey0ZHgZOCN4FZraNmXUCngSGmVkrM2uLh+zWl/bAZ8HQdMU9tAzNgO+H7aOBpyUtAd4zs6PCZygzs6iN9BKJYpOMTaLBImkh8GPgDjN7lRBCk7QCD5s9YGav4An8mvgJ0N/MZuLJ/W6SFuFhudfM7PehHt3fgGfDeZOAtpJewcNd/wKmAi/W8VEvMLO5mT+8tUMLM3sTuAw3mhmWA73M7DU8zHdJ2H8MMNrM/oXnloau73VKJOoDqVxNIpFIJIpO8mwSiUQiUXSSsUkkEolE0UnGJpFIJBJFJxmbRCKRSBSdZGwSiUQiUXSSsUkkEolE0UnGJpFIJBJFJxmbRCKRSBSd/wdvJM98ncdsqQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 720x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "spr = 10  # dB\n",
    "\n",
    "predictions = list()\n",
    "labels = list()\n",
    "for x, y in dl:\n",
    "    # Before crafting an attack on X, ensure that it is normalized to have a\n",
    "    # specified power -- RML2016.10a fluctuates a bit, especially on AM-SSB,\n",
    "    # which will cause the attack intensity to be incorrect.\n",
    "    x = _normalize(x)\n",
    "    adv_x = fgsm(x, y, spr=spr, input_size=input_samples, sps=1, net=model)\n",
    "\n",
    "    # Ensure that we've accurately represented the attack power\n",
    "    _sanity_check(desired_spr=spr, adv_x=adv_x, x=x)\n",
    "\n",
    "    _predictions = model.predict(adv_x)\n",
    "    predictions.extend(_predictions.detach().numpy())\n",
    "    labels.extend(y)\n",
    "\n",
    "cmn = _confusion_matrix(predictions=predictions, labels=labels, le=le)\n",
    "\n",
    "title = \"Confusion Matrix with a {spr} dB FGSM Attack\".format(spr=spr)\n",
    "fig = plot_confusion(cm=cmn, labels=le.labels, title=title)\n",
    "if fig_dir is not None:\n",
    "    file_path = \"{fig_dir}/fgsm_confusion_matrix.pdf\"\n",
    "    print(\"Saving Figure -> {file_path}\".format(file_path=file_path))\n",
    "    fig.savefig(file_path, format=\"pdf\", transparent=True)\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
